diff -r 000000000000 -r a2952bb97e68 mmappcomponents/mmmtpdataprovider/tsrc/mtpdataprovidertestmodule/src/cmediamtpdataprovidertester.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mmappcomponents/mmmtpdataprovider/tsrc/mtpdataprovidertestmodule/src/cmediamtpdataprovidertester.cpp	Thu Dec 17 08:55:47 2009 +0200
@@ -0,0 +1,1557 @@
+/*
+* 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:  Tester class for mediamtpdp plugin
+*
+*/
+
+
+#include <e32def.h>
+#include <stiftestinterface.h>
+#include <settingserverclient.h>
+#include <mtp/mtpprotocolconstants.h>
+#include <mtp/cmtptypeobjectinfo.h>
+#include <mtp/cmtptypefile.h>
+#include <mtp/cmtptypestring.h>
+#include <mtp/cmtptypearray.h>
+#include <mtp/cmtptypeobjectproplist.h>
+#include <mtp/cmtptypeobjectpropdesc.h>
+#include <bautils.h>
+#include <f32file.h>
+#include <mpxharvesterutility.h>
+#include "cmediamtpdataprovidertester.h"
+#include "logging.h"
+
+#ifdef LOGGER
+#undef LOGGER
+#endif
+#define LOGGER iLog
+
+// definitions and constants for the test data
+
+const TUint32 KTestStorageId = 0x10000;
+const TInt KTestObjectsCount = 4;
+const TUint KTestDirHandle = 1;
+const TInt KTestDirDataproviderId = 0;
+_LIT( KTempDirPath, "C:\\mtp_testdata\\temp\\" );
+_LIT( KTestDirPath, "C:\\mtp_testdata\\temp\\TESTDIR\\" );
+_LIT( KTestFileOrigPath, "C:\\mtp_testdata\\TEST.MP3" );
+_LIT( KTestFileTempPath, "C:\\mtp_testdata\\temp\\TEST.MP3" );
+_LIT( KTestDirOrigPath, "C:\\mtp_testdata\\TESTDIR\\*" );
+_LIT( KTestDirTempPath, "C:\\mtp_testdata\\temp\\TESTDIR\\" );
+_LIT( KTestDirPhysicalStorage, "C:\\mtp_testdata\\temp\\" );
+_LIT( KTestDirLogicalStorage, "C:\\mtp_testdata\\temp\\" );
+_LIT( KTestObjectPath1, "C:\\mtp_testdata\\temp\\TEST.MP3" );
+_LIT( KTestObjectPath2, "C:\\mtp_testdata\\temp\\TESTDIR\\TEST1.MP3" );
+_LIT( KTestObjectPath3, "C:\\mtp_testdata\\temp\\TESTDIR\\TEST2.MP3" );
+
+_LIT( KSendTestObjectFile, "SENDTEST.MP3" );
+_LIT( KSendTestObjectFileFullPath, "C:\\mtp_testdata\\SENDTEST.MP3" );
+_LIT( KSendTestObjectPath, "C:\\mtp_testdata\\temp\\SENDTEST.MP3" );
+_LIT( KSendTestObjectDateString, "20090511T091022+0800" );
+_LIT( KCopyTestObjectPath, "C:\\mtp_testdata\\temp\\TEST1.MP3" );
+_LIT( KCopyTestFileName, "TEST1.MP3" );
+_LIT( KMoveTestObjectOldPath, "C:\\mtp_testdata\\temp\\TESTDIR\\TEST1.MP3" );
+_LIT( KMoveTestObjectNewPath, "C:\\mtp_testdata\\temp\\TEST1.MP3" );
+_LIT( KMoveTestFileName, "TEST1.MP3" );
+_LIT( KRenameObjectName, "TESTDIR" );
+_LIT( KRenameObjectPath, "C:\\mtp_testdata\\temp\\RENAMEDIR\\" );
+
+//_LIT( KSendObjectNameString, "Test Object" );
+
+_LIT( KPropObjectDate, "20090610T090000+0800" );
+_LIT( KPropObjectName, "Test Object" );
+_LIT( KPropObjectArtist, "Test Artist" );
+_LIT( KPropObjectAlbumName, "Test Album" );
+
+const TInt KTestFileSize = 271890;
+const TInt KSendTestFileSize = 271890;
+const TInt KCopyTestFileSize = 271890;
+const TInt KMoveTestFileSize = 271890;
+
+// ----------------------------------------------------------------------------
+// Two-phased constructor.
+// ----------------------------------------------------------------------------
+//
+CMediaMtpDataProviderTester* CMediaMtpDataProviderTester::NewL()
+    {
+    CMediaMtpDataProviderTester* self = 
+            new ( ELeave ) CMediaMtpDataProviderTester();
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop( self );
+    return self;
+    }
+
+// ----------------------------------------------------------------------------
+// C++ default constructor can NOT contain any code, that might leave.
+// ----------------------------------------------------------------------------
+//
+CMediaMtpDataProviderTester::CMediaMtpDataProviderTester()
+        : CMmMtpDataProviderTester()
+    {
+    // no implementation required
+    }
+
+// ----------------------------------------------------------------------------
+// Symbian 2nd phase constructor can leave.
+// ----------------------------------------------------------------------------
+//
+void CMediaMtpDataProviderTester::ConstructL()
+    {
+    TFileName logFileName;
+    logFileName.Copy( KMtpDataProviderTestModuleLogFile );
+    
+    iLog = CStifLogger::NewL( KMtpDataProviderTestModuleLogPath, 
+                          logFileName,
+                          CStifLogger::ETxt,
+                          TRACE_TARGET,
+                          ETrue, ETrue, ETrue, EFalse, ETrue );
+    PRINTF0( ">CMediaMtpDataProviderTester::ConstructL" );
+    iActiveSchedulerWait = new ( ELeave ) CActiveSchedulerWait();
+    iFsSession.Connect();
+    iFileMan = CFileMan::NewL( iFsSession );
+    PRINTF0( "<CMediaMtpDataProviderTester::ConstructL" );
+    }
+
+// ----------------------------------------------------------------------------
+// Destructor.
+// ----------------------------------------------------------------------------
+//  
+CMediaMtpDataProviderTester::~CMediaMtpDataProviderTester()
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::~CMediaMtpDataProviderTester" );
+    delete iActiveSchedulerWait;
+    delete iFileMan;
+    iFsSession.Close();
+    PRINTF0( "<CMediaMtpDataProviderTester::~CMediaMtpDataProviderTester" );
+    delete iLog;
+    }
+
+TInt CMediaMtpDataProviderTester::PrepareEnvironmentL()
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::PrepareEnvironmentL" );
+    TInt result = KErrNone;
+    
+    result = iFileMan->RmDir( KTempDirPath );
+    if ( result == KErrNone )
+        {
+        PRINTN0( "Warning: old temp directory found, deleted" );
+        }
+    result = KErrNone;
+    
+    // create the temp dir if it doesn't exist
+    BaflUtils::EnsurePathExistsL( iFsSession, KTempDirPath );
+    
+    // copy the test data to temp dir
+    result = iFileMan->Copy( KTestFileOrigPath, KTestFileTempPath );
+    if ( result != KErrNone ) 
+        {
+        PRINTE1( "Failed to copy test file, error %d", result );
+        }
+    else
+        {
+        result = iFileMan->Copy( KTestDirOrigPath, KTestDirTempPath,
+                CFileMan::EOverWrite | CFileMan::ERecurse );
+        if ( result != KErrNone ) 
+            {
+            PRINTE1( "Failed to copy test dir, error %d", result );
+            }
+        }
+    
+    PRINTF1( "<CMediaMtpDataProviderTester::PrepareEnvironmentL result = %d", result );
+    return result;
+    }
+
+TInt CMediaMtpDataProviderTester::CleanEnvironmentL()
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::CleanEnvironmentL" );
+    TInt result = KErrNone;
+    TMTPObjectMgrQueryParams queryParams ( KMTPStorageAll, KMTPFormatsAll,
+            KMTPHandleNone );
+    RMTPObjectMgrQueryContext context;
+    RArray<TUint> handles;
+    CleanupClosePushL( handles );
+
+    PRINTN0( "Starting to delete entries from mpx" );
+    MMPXHarvesterUtility* harvester = CMPXHarvesterFactory::NewL();
+    CleanupClosePushL( *harvester );
+    
+    iTestObserver->ObjectMgr().GetObjectHandlesL( queryParams, context,
+            handles );
+    PRINTV1( "Handle count: %d", handles.Count() );
+    context.Close();
+    
+    CMTPObjectMetaData* metadata = CMTPObjectMetaData::NewLC();
+    for ( TInt i = 0; i < handles.Count(); i++ )
+        {
+        PRINTN0( "enter for loop" );
+        TUint handle = handles[i];
+            if ( handle != KTestDirHandle )
+                {
+                iTestObserver->ObjectMgr().ObjectL( handles[i], *metadata );
+                TPtrC fileName = metadata->DesC( CMTPObjectMetaData::ESuid );
+                PRINTV1( "Handle: %d", handles[i] );
+                PRINTV1( "File name: %S", &fileName );
+                    
+                PRINTN0( "Starting to delete the file from mpx" );
+                iTestObserver->SetPendingOperation( CTestObserver::EHarvesterDeleteObject );
+                PRINTN0( "before deletefilel" );
+                harvester->DeleteFileL( fileName, iTestObserver );
+                PRINTN0( "after deletefilel" );
+                User::After( 1000000 );
+                PRINTN0( "before waitforpendingoperation" );
+                // waiting for asynchronous operation to complete
+                result = iTestObserver->WaitForPendingOperation();
+                PRINTN0( "after waitforpendingoperation" );
+                    
+            if ( result != KErrNone )
+                {
+                PRINTE1( "Warning: failed to delete from mpx, error %d", result );
+                result = KErrNone; // ignore for now, there are problems after DeleteObject
+                }
+            }
+        }
+    CleanupStack::PopAndDestroy( 3 ); // metadata, harvester, handles
+    PRINTN0( "Finished deleting entries from mpx" );
+    
+    if ( result == KErrNone )
+        {
+        PRINTN0( "Deleting temp directory" );
+        result = iFileMan->RmDir( KTempDirPath );
+        if ( result != KErrNone )
+            {
+            PRINTE1( "Warning: failed to delete temp directory, error %d", result );
+            result = KErrNone;
+            }
+        }
+    
+    PRINTF1( "<CMediaMtpDataProviderTester::CleanEnvironmentL result = %d", result );
+    return result;
+    }
+
+TBool CMediaMtpDataProviderTester::ObjectEnumerationL_prepare(
+        CMTPStorageMetaData* aPhysicalStorage,
+        CMTPStorageMetaData* aLogicalStorage )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::ObjectEnumerationL_prepare" );
+    
+    TBool result = ETrue;
+    aPhysicalStorage->SetDesCL( CMTPStorageMetaData::EStorageSuid,
+            KTestDirPhysicalStorage() );
+    aPhysicalStorage->SetUint( CMTPStorageMetaData::EStorageSystemType,
+            CMTPStorageMetaData::ESystemTypeDefaultFileSystem );
+    
+    aLogicalStorage->SetDesCL( CMTPStorageMetaData::EStorageSuid,
+            KTestDirLogicalStorage() );
+    aLogicalStorage->SetUint( CMTPStorageMetaData::EStorageSystemType,
+            CMTPStorageMetaData::ESystemTypeDefaultFileSystem );
+    
+    // insert TESTDIR object manually
+    CMTPObjectMetaData* object( CMTPObjectMetaData::NewLC( 0,
+            EMTPFormatCodeAssociation, // a folder object
+            KTestStorageId, KTestDirPath ) );
+    // object is in storage root
+    object->SetInt( CMTPObjectMetaData::EParentId, KErrNotFound );
+    
+    iTestObserver->ObjectMgr().InsertObjectL( *object );
+    CleanupStack::PopAndDestroy( object );
+    
+    PRINTF1( "<CMediaMtpDataProviderTester::ObjectEnumerationL_prepare result = %d", result );
+    return result;
+    }
+
+TInt CMediaMtpDataProviderTester::ObjectEnumerationL_checkresults(
+        MMTPObjectMgr& aObjectManager )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::ObjectEnumerationL_checkresults" );
+    
+    TInt result = KErrNone;
+    
+    TMTPObjectMgrQueryParams queryParams ( KMTPStorageAll, KMTPFormatsAll,
+            KMTPHandleNone );
+    RMTPObjectMgrQueryContext context;
+    RArray<TUint> handles;
+    CleanupClosePushL( handles );
+    MMPXHarvesterUtility* harvester = CMPXHarvesterFactory::NewL();
+    CleanupClosePushL( *harvester );
+    
+    aObjectManager.GetObjectHandlesL( queryParams, context, handles );
+    context.Close();
+    TInt count = handles.Count();
+    PRINTV1( "Handle count: %d", count );
+    if ( count != KTestObjectsCount ) 
+        {
+        PRINTE2( "Wrong number of handles: %d != %d", count, KTestObjectsCount );
+        result = KErrGeneral;
+        }
+    
+    CMTPObjectMetaData* metadata = CMTPObjectMetaData::NewLC();
+    for ( TInt i = 0; i < count; i++ )
+        {
+        TUint handle = handles[i];
+        aObjectManager.ObjectL( handle, *metadata );
+        TPtrC suid = metadata->DesC( CMTPObjectMetaData::ESuid );
+        TUint formatCode = metadata->Uint( CMTPObjectMetaData::EFormatCode );
+        TUint dataproviderId = metadata->Uint( CMTPObjectMetaData::EDataProviderId );
+        TUint storageId = metadata->Uint( CMTPObjectMetaData::EStorageId );
+        TInt parentId = metadata->Int( CMTPObjectMetaData::EParentId );
+        
+        PRINTN1( "Handle: %d", handle );
+        PRINTN1( "Suid: %S", &suid );
+        
+        if ( dataproviderId != iTestObserver->DataProviderId() )
+            {
+            if ( !( ( handle == KTestDirHandle ) &&
+                    ( dataproviderId == KTestDirDataproviderId ) ) )
+                {
+                PRINTE2( "Wrong dataprovider id: %d != %d", dataproviderId, iTestObserver->DataProviderId() );
+                result = KErrGeneral;
+                }
+            }
+        if ( storageId != KTestStorageId )
+            {
+            PRINTE2( "Wrong storage id: %d != %d", storageId, KTestStorageId );
+            result = KErrGeneral;
+            }
+        switch ( handle )
+            {
+            case 1:
+                {
+                if ( suid.Match( KTestDirPath ) != 0 )
+                    {
+                    PRINTE2( "Wrong test dir path: %S != %S", &suid, &KTestDirPath );
+                    result = KErrGeneral;
+                    }
+                if ( formatCode != EMTPFormatCodeAssociation )
+                    {
+                    PRINTE2( "Wrong format code: 0x%x != 0x%x", formatCode, EMTPFormatCodeAssociation );
+                    result = KErrGeneral;
+                    }
+                if ( parentId != KErrNotFound )
+                    {
+                    PRINTE2( "Wrong parent id: %d != %d", parentId, KErrNotFound );
+                    result = KErrGeneral;
+                    }
+                break;
+                }
+            case 2:
+                {
+                if ( suid.Match( KTestObjectPath1 ) != 0 )
+                    {
+                    PRINTE2( "Wrong test object 1 path: %S != %S", &suid, &KTestObjectPath1 );
+                    result = KErrGeneral;
+                    }
+                if ( formatCode != EMTPFormatCodeMP3 )
+                    {
+                    PRINTE2( "Wrong format code: 0x%x != 0x%x", formatCode, EMTPFormatCodeMP3 );
+                    result = KErrGeneral;
+                    }
+                if ( parentId != KErrNotFound )
+                    {
+                    PRINTE2( "Wrong parent id: %d != %d", parentId, KErrNotFound );
+                    result = KErrGeneral;
+                    }
+                break;
+                }
+            case 3:
+                {
+                if ( suid.Match( KTestObjectPath2 ) != 0 )
+                    {
+                    PRINTE2( "Wrong test object 2 path: %S != %S", &suid, KTestObjectPath2 );
+                    result = KErrGeneral;
+                    }
+                if ( formatCode != EMTPFormatCodeMP3 )
+                    {
+                    PRINTE2( "Wrong format code: 0x%x != 0x%x", formatCode, EMTPFormatCodeMP3 );
+                    result = KErrGeneral;
+                    }
+                if ( parentId != 1 )
+                    {
+                    PRINTE2( "Wrong parent id: %d != %d", parentId, 1 );
+                    result = KErrGeneral;
+                    }
+                break;
+                }
+            case 4:
+                {
+                if ( suid.Match( KTestObjectPath3 ) != 0 )
+                    {
+                    PRINTE2( "Wrong test object 3 path: %S != %S", &suid, &KTestObjectPath3 );
+                    result = KErrGeneral;
+                    }
+                if ( formatCode != EMTPFormatCodeMP3 )
+                    {
+                    PRINTE2( "Wrong format code: 0x%x != 0x%x", formatCode, EMTPFormatCodeMP3 );
+                    result = KErrGeneral;
+                    }
+                if ( parentId != 1 )
+                    {
+                    PRINTE2( "Wrong parent id: %d != %d", parentId, 1 );
+                    result = KErrGeneral;
+                    }
+                break;
+                }
+            default:
+                {
+                PRINTE1( "Unexpected handle: %d", handle );
+                result = KErrGeneral;
+                }
+            }
+        
+        if ( ( result == KErrNone ) && ( handle != KTestDirHandle ) )
+            {
+            PRINTN0( "Starting to harvest the file" );
+            iTestObserver->SetPendingOperation( CTestObserver::EHarvesterAddObject );
+            harvester->AddFileL( metadata->DesC( CMTPObjectMetaData::ESuid ), iTestObserver );
+            PRINTN0( "Waiting for harvesting to complete" );
+            result = iTestObserver->WaitForPendingOperation();
+            if ( result != KErrNone )
+                {
+                PRINTE1( "Harvesting error: %d", result );
+                }
+            }
+        }
+    CleanupStack::PopAndDestroy( 3 ); // handles, harvester, metadata
+    PRINTF1( "<CMediaMtpDataProviderTester::ObjectEnumerationL_checkresults result = %d", result );
+    return result;
+    }
+
+TInt CMediaMtpDataProviderTester::GetObjectInfoL_checkresults(
+        const CMTPTypeObjectInfo* aObjectInfo )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::GetObjectInfoL_checkresults" );
+    _LIT( KTestFileName, "TEST.MP3" );
+    TInt result = KErrNone;
+    if ( aObjectInfo )
+        {
+        PRINTV1( "Object filename: %S", &aObjectInfo->StringCharsL( CMTPTypeObjectInfo::EFilename ) );
+        if ( aObjectInfo->StringCharsL( CMTPTypeObjectInfo::EFilename ).
+                CompareF( KTestFileName ) != 0 )
+            {
+            PRINTE0( "ObjectInfo filename not correct" );
+            result = KErrGeneral;
+            }
+        PRINTV1( "Object modified date: %S", &aObjectInfo->StringCharsL( CMTPTypeObjectInfo::EDateModified ) );
+        if ( aObjectInfo->StringCharsL( CMTPTypeObjectInfo::EDateModified ).
+                Length() == 0 )
+            {
+            PRINTE0( "ObjectInfo modified date not set" );
+            }
+        PRINTV1( "Object formatcode: 0x%x", aObjectInfo->Uint16L( CMTPTypeObjectInfo::EObjectFormat ) );
+        if ( aObjectInfo->Uint16L( CMTPTypeObjectInfo::EObjectFormat ) !=
+                EMTPFormatCodeMP3 )
+            {
+            PRINTE0( "ObjectInfo format code not correct" );
+            result=KErrGeneral;
+            }
+        }
+    else
+        {
+        PRINTE0( "ObjectInfo not received correctly" );
+        result = KErrArgument;
+        }
+    PRINTF1( "<CMediaMtpDataProviderTester::GetObjectInfoL_checkresults result = %d", result );
+    return result;
+    }
+
+TInt CMediaMtpDataProviderTester::GetObjectL_checkresults(
+        CMTPTypeFile* aObjectInfo )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::GetObjectL_checkresults" );
+    // just check the handle is correct, based on the size
+    TInt result = KErrNone;
+    if ( aObjectInfo )
+        {
+        TInt size = aObjectInfo->Size();
+        PRINTV1( "Received object size: %d", size );
+        if ( size != KTestFileSize )
+            {
+            PRINTE2( "Wrong received object size: %d != %d", KTestFileSize, size );
+            result =  KErrGeneral;
+            }
+        aObjectInfo->File().Close();
+        }
+    else
+        {
+        PRINTE0( "Object info not received" );
+        result = KErrArgument;
+        }
+    PRINTF1( "<CMediaMtpDataProviderTester::GetObjectL_checkresults result = %d", result );
+    return result;
+    }
+
+TInt CMediaMtpDataProviderTester::GetObjectPropValueL_checkresults(
+        const MMTPType* aObjectPropValue, const TUint aPropCode )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::GetObjectPropValueL_checkresults" );
+    TInt type = aObjectPropValue->Type();
+    PRINTV1( "Received data type: 0x%x", type );
+    TInt result = KErrNone;
+    
+    switch ( aPropCode )
+        {
+        case EMTPObjectPropCodeStorageID:
+            {
+            TUint32 value = static_cast<const TMTPTypeUint32*>( aObjectPropValue )->Value();
+            PRINTV1( "Storage ID: 0x%x", value );
+            if ( value == KTestStorageId )
+                {
+                result = KErrNone;
+                }
+            }
+            break;
+        case EMTPObjectPropCodeObjectFormat:
+            {
+            TUint16 value = static_cast<const TMTPTypeUint16*>( aObjectPropValue )->Value();
+            PRINTV1( "Format: 0x%x", value );
+            if ( value == EMTPFormatCodeMP3 )
+                {
+                result = KErrNone;
+                }
+            }
+            break;
+        case EMTPObjectPropCodeProtectionStatus:
+            {
+            TUint16 value = static_cast<const TMTPTypeUint16*>( aObjectPropValue )->Value();
+            PRINTV1( "Protections status: 0x%x", value );
+            if ( value == EMTPProtectionNoProtection )
+                {
+                result = KErrNone;
+                }
+            }
+            break;
+        case EMTPObjectPropCodeObjectSize:
+            {
+            TUint64 value = static_cast<const TMTPTypeUint64*>( aObjectPropValue )->Value();
+            PRINTV1( "Object size: %d", value );
+            if ( value == KTestFileSize )
+                {
+                result = KErrNone;
+                }
+            }
+            break;
+        case EMTPObjectPropCodeObjectFileName:
+            {
+            TPtrC value = static_cast<const CMTPTypeString*>( aObjectPropValue )->StringChars();
+            PRINTV1( "Object file name: '%S'", &value );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeParentObject:
+            {
+            TUint32 value = static_cast<const TMTPTypeUint32*>( aObjectPropValue )->Value();
+            PRINTV1( "Parent object: %d", value );
+            if ( value == KMaxTUint32 )
+                {
+                result = KErrNone;
+                }
+            }
+            break;
+        case EMTPObjectPropCodePersistentUniqueObjectIdentifier:
+            {
+            /*
+            TUint64 lower = static_cast<const TMTPTypeUint128*>( aObjectPropValue )->LowerValue();
+            TUint64 upper = static_cast<const TMTPTypeUint128*>( aObjectPropValue )->UpperValue();
+            __TRACE( KPrint, ( _L( "Unique identifier: 0x%x 0x%x" ), lower, upper ) );
+            if ( ( lower == 1) && ( upper == 1 ) )
+                {
+                result = KErrNone;
+                }
+            */
+            }
+            break;
+        case EMTPObjectPropCodeName:
+            {
+            TPtrC value = static_cast<const CMTPTypeString*>( aObjectPropValue )->StringChars();
+            PRINTV1( "Object name: '%S'", &value );
+            if ( value.Match( KPropObjectName ) != 0 )
+                {
+                PRINTE2( "Received object name does not match: '%S' != '%S'", &value, &KPropObjectName );
+                result = KErrGeneral;
+                }
+            }
+            break;
+        case EMTPObjectPropCodeNonConsumable:
+            {
+            TUint8 value = static_cast<const TMTPTypeUint8*>( aObjectPropValue )->Value();
+            PRINTV1( "Non-consumable: %d", value );
+            if ( value == 1 )
+                {
+                result = KErrNone;
+                }
+            }
+            break;
+        case EMTPObjectPropCodeDateAdded:
+            {
+            TPtrC value = static_cast<const CMTPTypeString*>( aObjectPropValue )->StringChars();
+            PRINTV1( "Date added: '%S'", &value );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeDateCreated:
+            {
+            TPtrC value = static_cast<const CMTPTypeString*>( aObjectPropValue )->StringChars();
+            PRINTV1( "Date created: '%S'", &value );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeDateModified:
+            {
+            TPtrC value = static_cast<const CMTPTypeString*>( aObjectPropValue )->StringChars();
+            PRINTV1( "Date modified: '%S'", &value );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeArtist:
+            {
+            TPtrC value = static_cast<const CMTPTypeString*>( aObjectPropValue )->StringChars();
+            PRINTV1( "Artist: '%S'", &value );
+            if ( value.Match( KPropObjectArtist ) != 0 )
+                {
+                PRINTE2( "Received object artist does not match: '%S' != '%S'", &value, &KPropObjectArtist );
+                result = KErrGeneral;
+                }
+            }
+            break;
+        case EMTPObjectPropCodeTrack:
+            {
+            TUint16 value = static_cast<const TMTPTypeUint16*>( aObjectPropValue )->Value();
+            PRINTV1( "Track: %d", value );
+            if ( value == 1 )
+                {
+                result = KErrNone;
+                }
+            }
+            break;
+        case EMTPObjectPropCodeGenre:
+            {
+            TPtrC value = static_cast<const CMTPTypeString*>( aObjectPropValue )->StringChars();
+            PRINTV1( "Genre: '%S'", &value );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeAlbumName:
+            {
+            TPtrC value = static_cast<const CMTPTypeString*>( aObjectPropValue )->StringChars();
+            PRINTV1( "Album name: '%S'", &value );
+            if ( value.Match( KPropObjectAlbumName ) != 0 )
+                {
+                PRINTE2( "Received object album name does not match: '%S' != '%S'", &value, &KPropObjectAlbumName );
+                result = KErrGeneral;
+                }
+            }
+            break;
+        case EMTPObjectPropCodeSampleRate:
+            {
+            TUint32 value = static_cast<const TMTPTypeUint16*>( aObjectPropValue )->Value();
+            PRINTV1( "Sample rate: %d", value );
+            if ( value == 1 )
+                {
+                result = KErrNone;
+                }
+            }
+            break;
+        case EMTPObjectPropCodeNumberOfChannels:
+            {
+            TUint16 value = static_cast<const TMTPTypeUint16*>( aObjectPropValue )->Value();
+            PRINTV1( "Number of channels: %d", value );
+            if ( value == 1 )
+                {
+                result = KErrNone;
+                }
+            }
+            break;
+        case EMTPObjectPropCodeAudioWAVECodec:
+            {
+            TUint32 value = static_cast<const TMTPTypeUint16*>( aObjectPropValue )->Value();
+            PRINTV1( "WAVE codec: %d", value );
+            if ( value == 1 )
+                {
+                result = KErrNone;
+                }
+            }
+            break;
+        case EMTPObjectPropCodeAudioBitRate:
+            {
+            TUint32 value = static_cast<const TMTPTypeUint16*>( aObjectPropValue )->Value();
+            PRINTV1( "Audio bit rate: %d", value );
+            if ( value == 1 )
+                {
+                result = KErrNone;
+                }
+            }
+            break;
+        case EMTPObjectPropCodeDuration:
+            {
+            TUint32 value = static_cast<const TMTPTypeUint16*>( aObjectPropValue )->Value();
+            PRINTV1( "Duration: %d", value );
+            if ( value == 1 )
+                {
+                result = KErrNone;
+                }
+            }
+            break;
+        case EMTPObjectPropCodeOriginalReleaseDate:
+            {
+            TPtrC value = static_cast<const CMTPTypeString*>( aObjectPropValue )->StringChars();
+            PRINTV1( "Original release date: '%S'", &value );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeDescription:
+            {
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeComposer:
+            {
+            TPtrC value = static_cast<const CMTPTypeString*>( aObjectPropValue )->StringChars();
+            PRINTV1( "Composer: '%S'", &value );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeWidth:
+        case EMTPObjectPropCodeHeight:
+        case EMTPObjectPropCodeUseCount:
+        case EMTPObjectPropCodeScanType:
+        case EMTPObjectPropCodeVideoFourCCCodec:
+        case EMTPObjectPropCodeVideoBitRate:
+        case EMTPObjectPropCodeFramesPerThousandSeconds:
+        case EMTPObjectPropCodeKeyFrameDistance:
+        case EMTPObjectPropCodeEncodingProfile:
+        case EMTPObjectPropCodeParentalRating:
+            {
+            result = KErrNone;
+            }
+            break;
+        default:
+            {
+            PRINTE1( "Unsupported prop code: %d", aPropCode );
+            result = KErrArgument;
+            }
+        }
+    PRINTF1( "<CMediaMtpDataProviderTester::GetObjectPropValueL_checkresults result = %d", result );
+    return result;
+    }
+
+TInt CMediaMtpDataProviderTester::GetObjectPropListL_checkresults(
+        const CMTPTypeObjectPropList* aObjectPropList )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::GetObjectPropListL_checkresults" );
+    TInt result = KErrNone;
+    TUint32 count = aObjectPropList->NumberOfElements();
+    PRINTV1( "PropList elements received: %d", count );
+    for ( TUint32 i = 0; i < count; i++ )
+        {
+        CMTPTypeObjectPropListElement& element = aObjectPropList->Element( i );
+        TUint32 handle = element.Uint32L( CMTPTypeObjectPropListElement::EObjectHandle );
+        PRINTV1( "Object handle: %d", handle );
+        TUint16 dataType = element.Uint16L( CMTPTypeObjectPropListElement::EDatatype );
+        PRINTV1( "Data type: 0x%x", dataType );
+        TUint16 propCode = element.Uint16L( CMTPTypeObjectPropListElement::EPropertyCode );
+        PRINTV1( "Prop code: 0x%x", propCode );
+        if ( propCode == EMTPObjectPropCodeName )
+            {
+            if ( dataType == EMTPTypeString )
+                {
+                TPtrC name = element.StringCharsL( CMTPTypeObjectPropListElement::EValue );
+                PRINTN1( "Object name: %S", &name );
+                if ( name.Match( KPropObjectName ) != 0 )
+                    {
+                    PRINTE2( "Object modified date is incorrect: %S != %S", &name, &KPropObjectName );
+                    result = KErrGeneral;
+                    }
+                }
+            else
+                {
+                PRINTE2( "Wrong datatype received, 0x%x != 0x%x", dataType, EMTPTypeString );
+                result = KErrArgument;
+                }
+            }
+        }
+    
+    PRINTF1( "<CMediaMtpDataProviderTester::GetObjectPropListL_checkresults result = %d", result );
+    return result;
+    }
+
+TInt CMediaMtpDataProviderTester::GetObjectPropDescL_checkresults(
+        const CMTPTypeObjectPropDesc* aObjectPropDesc, const TUint aPropCode )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::GetObjectPropDescL_checkresults" );
+    TUint16 propertyCode = aObjectPropDesc->Uint16L( CMTPTypeObjectPropDesc::EPropertyCode );
+    TUint16 dataType = aObjectPropDesc->Uint16L( CMTPTypeObjectPropDesc::EDatatype );
+    TUint8 getSet = aObjectPropDesc->Uint8L( CMTPTypeObjectPropDesc::EGetSet );
+    TUint8 formFlag = aObjectPropDesc->Uint8L( CMTPTypeObjectPropDesc::EFormFlag );
+
+    TInt result = KErrNone;
+    
+    PRINTV4( "Property code: 0x%x, data type: 0x%x, form flag: 0x%x, get/set: 0x%x", propertyCode, dataType, formFlag, getSet );
+    
+    if ( formFlag != CMTPTypeObjectPropDesc::ENone )
+        {
+        switch ( formFlag )
+            {
+            case CMTPTypeObjectPropDesc::ERangeForm:
+                PRINTV0( "Range form" );
+                break;
+            case CMTPTypeObjectPropDesc::EEnumerationForm:
+                PRINTV0( "Enumeration form" );
+                break;
+            case CMTPTypeObjectPropDesc::EDateTimeForm:
+                PRINTV0( "Datetime form" );
+                break;
+            case CMTPTypeObjectPropDesc::EFixedLengthArrayForm:
+                PRINTV0( "Fixed length array form" );
+                break;
+            case CMTPTypeObjectPropDesc::ERegularExpressionForm:
+                PRINTV0( "Regular expression form" );
+                break;
+            case CMTPTypeObjectPropDesc::EByteArrayForm:
+                PRINTV0( "Byte array form" );
+                break;
+            case CMTPTypeObjectPropDesc::ELongStringForm:
+                PRINTV0( "Long string form" );
+            default:
+                {
+                PRINTE0( "Invalid form" );
+                result = KErrArgument;
+                }
+            }
+        }
+    
+    switch ( aPropCode )
+        {
+        case EMTPObjectPropCodeStorageID:
+            {
+            PRINTV0( "Storage ID" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeObjectFormat:
+            {
+            PRINTV0( "Object format" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeProtectionStatus:
+            {
+            PRINTV0( "Protection status" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeObjectSize:
+            {
+            PRINTV0( "Object size" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeObjectFileName:
+            {
+            PRINTV0( "Object file name" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeParentObject:
+            {
+            PRINTV0( "Parent object" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodePersistentUniqueObjectIdentifier:
+            {
+            PRINTV0( "Unique object identifier" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeName:
+            {
+            PRINTV0( "Name" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeNonConsumable:
+            {
+            PRINTV0( "Non consumable" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeDateAdded:
+            {
+            PRINTV0( "Date added" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeDateCreated:
+            {
+            PRINTV0( "Date created" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeDateModified:
+            {
+            PRINTV0( "Date modified" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeArtist:
+            {
+            PRINTV0( "Artist" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeTrack:
+            {
+            PRINTV0( "Track" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeGenre:
+            {
+            PRINTV0( "Genre" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeAlbumName:
+            {
+            PRINTV0( "Album name" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeSampleRate:
+            {
+            PRINTV0( "Sample rate" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeNumberOfChannels:
+            {
+            PRINTV0( "Number of channels" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeAudioWAVECodec:
+            {
+            PRINTV0( "Audio wave codec" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeAudioBitRate:
+            {
+            PRINTV0( "Audio bitrate" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeDuration:
+            {
+            PRINTV0( "Duration" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeOriginalReleaseDate:
+            {
+            PRINTV0( "Original release date" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeDescription:
+            {
+            PRINTV0( "Description" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeComposer:
+            {
+            PRINTV0( "Composer" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeWidth:
+            {
+            PRINTV0( "Width" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeHeight:
+            {
+            PRINTV0( "Height" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeUseCount:
+            {
+            PRINTV0( "Use count" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeScanType:
+            {
+            PRINTV0( "Scan type" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeVideoFourCCCodec:
+            {
+            PRINTV0( "Video 4cc codec" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeVideoBitRate:
+            {
+            PRINTV0( "Video bitrate" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeFramesPerThousandSeconds:
+            {
+            PRINTV0( "Frames per thousand seconds" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeKeyFrameDistance:
+            {
+            PRINTV0( "Key frame distance" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeEncodingProfile:
+            {
+            PRINTV0( "Encoding profile" );
+            result = KErrNone;
+            }
+            break;
+        case EMTPObjectPropCodeParentalRating:
+            {
+            PRINTV0( "Parental rating" );
+            result = KErrNone;
+            }
+            break;
+        default:
+            {
+            PRINTE1( "Unsupported prop code: %d", aPropCode );
+            result = KErrArgument;
+            }
+        }
+    PRINTF1( "<CMediaMtpDataProviderTester::GetObjectPropDescL_checkresults result = %d", result );
+    return result;
+    }
+
+TBool CMediaMtpDataProviderTester::SendObjectInfoL_prepare(
+        TMTPTypeRequest& aRequest )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::SendObjectInfoL_prepare" );
+    TBool result = ETrue;
+    TUint32 storageId = KTestStorageId; // physical storage
+    aRequest.SetUint32( TMTPTypeRequest::ERequestParameter1, storageId );
+    PRINTF1( "<CMediaMtpDataProviderTester::SendObjectInfoL_prepare result = %d", result );
+    return result;
+    }
+
+void CMediaMtpDataProviderTester::SendObjectInfoReceiveData(
+        CMTPTypeObjectInfo* aData )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::SendObjectInfoReceiveData" );
+    aData->SetUint32L( CMTPTypeObjectInfo::EStorageID, KTestStorageId );
+    aData->SetUint16L( CMTPTypeObjectInfo::EObjectFormat, EMTPFormatCodeMP3 );
+    aData->SetStringL( CMTPTypeObjectInfo::EFilename, KSendTestObjectFile );
+    aData->SetStringL( CMTPTypeObjectInfo::EDateModified, KSendTestObjectDateString );
+    aData->SetUint32L( CMTPTypeObjectInfo::EObjectCompressedSize, KSendTestFileSize );
+    PRINTF0( "<CMediaMtpDataProviderTester::SendObjectInfoReceiveData" );
+    }
+
+TBool CMediaMtpDataProviderTester::SendObjectL_prepare(
+        TMTPTypeRequest& aRequest )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::SendObjectL_prepare" );
+    TBool result = ETrue;
+    TUint32 storageId = KTestStorageId; // physical storage
+    aRequest.SetUint32( TMTPTypeRequest::ERequestParameter1, storageId );
+    PRINTF1( "<CMediaMtpDataProviderTester::SendObjectL_prepare result = %d", result );
+    return result;
+    }
+
+void CMediaMtpDataProviderTester::SendObjectReceiveDataL( CMTPTypeFile* aData )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::SendObjectReceiveDataL" );
+    CMTPTypeFile* fileObject = CMTPTypeFile::NewL( iFsSession,
+            KSendTestObjectFileFullPath, EFileRead  );
+    CMTPTypeFile::CopyL( *fileObject, *aData );
+    delete fileObject;
+    aData->File().Close();
+    PRINTF0( "<CMediaMtpDataProviderTester::SendObjectReceiveDataL" );
+    }
+
+TInt CMediaMtpDataProviderTester::SendObjectL_checkresults()
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::SendObjectL_checkresults" );
+    TInt result = KErrNone;
+    TEntry entry;
+    if ( !BaflUtils::FileExists( iFsSession, KSendTestObjectPath ) )
+        {
+        PRINTE0( "Sent file does not exist" );
+        result = KErrGeneral;
+        }
+    else
+        {
+        result = iFsSession.Entry( KSendTestObjectPath, entry );
+        if ( result != KErrNone )
+            {
+            PRINTE1( "Could not read file entry, error: %d", result );
+            }
+        else
+            {
+            if ( entry.iSize != KSendTestFileSize )
+                {
+                PRINTE2( "Sent file size is incorrect: %d != %d", entry.iSize, KSendTestFileSize );
+                result = KErrGeneral;
+                }
+            }
+        }
+    if ( result == KErrNone )
+        {
+        CMTPObjectMetaData* metadata = CMTPObjectMetaData::NewLC();
+        iTestObserver->ObjectMgr().ObjectL( KSendTestObjectPath, *metadata );
+        if ( metadata->Uint( CMTPObjectMetaData::EHandle ) <= 0 )
+            {
+            PRINTE1( "Object handle not found: %d", metadata->Uint( CMTPObjectMetaData::EHandle ) );
+            result = KErrGeneral;
+            }
+        if ( metadata->Uint( CMTPObjectMetaData::EFormatCode ) != EMTPFormatCodeMP3 )
+            {
+            PRINTE1( "Wrong format code: %d", metadata->Uint( CMTPObjectMetaData::EFormatCode ) );
+            result = KErrGeneral;
+            }
+        CleanupStack::PopAndDestroy( metadata );
+        }
+    PRINTF1( "<CMediaMtpDataProviderTester::SendObjectL_checkresults result = %d", result );
+    return result;
+    }
+
+void CMediaMtpDataProviderTester::SetObjectPropValueReceiveDataL(
+        const TMTPTypeRequest& aRequest, MMTPType* aData )
+    {
+    TUint32 propCode = aRequest.Uint32( TMTPTypeRequest::ERequestParameter2 );
+    TUint type = aData->Type();
+    switch ( propCode )
+        {
+        case EMTPObjectPropCodeName:
+            if ( type != EMTPTypeString )
+                {
+                PRINTE2( "Incorrect data type: 0x%x != 0x%x", type, EMTPTypeString );
+                User::Leave( KErrArgument );
+                }
+            static_cast<CMTPTypeString*>( aData )->SetL( KPropObjectName );
+            break;
+        case EMTPObjectPropCodeArtist:
+            if ( type != EMTPTypeString )
+                {
+                PRINTE2( "Incorrect data type: 0x%x != 0x%x", type, EMTPTypeString );
+                User::Leave( KErrArgument );
+                }
+            static_cast<CMTPTypeString*>( aData )->SetL( KPropObjectArtist );
+            break;
+        case EMTPObjectPropCodeAlbumName:
+            if ( type != EMTPTypeString )
+                {
+                PRINTE2( "Incorrect data type: 0x%x != 0x%x", type, EMTPTypeString );
+                User::Leave( KErrArgument );
+                }
+            static_cast<CMTPTypeString*>( aData )->SetL( KPropObjectAlbumName );
+            break;
+        default:
+            PRINTE1( "Property code not supported: 0x%x", propCode );
+            User::Leave( KErrNotSupported );
+            break;
+        }
+    }
+
+void CMediaMtpDataProviderTester::SetObjectPropListReceiveDataL(
+        CMTPTypeObjectPropList* aData )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::SetObjectPropListReceiveDataL" );
+    CMTPTypeString* nameString = CMTPTypeString::NewLC( KPropObjectName );
+    CMTPTypeObjectPropListElement* newElement;
+    newElement = CMTPTypeObjectPropListElement::NewL( 1, static_cast<TUint16>( EMTPObjectPropCodeName ), *nameString );
+    aData->AppendL( newElement );
+    newElement = CMTPTypeObjectPropListElement::NewL( 2, static_cast<TUint16>( EMTPObjectPropCodeName ), *nameString );
+    aData->AppendL( newElement );
+    newElement = CMTPTypeObjectPropListElement::NewL( 3, static_cast<TUint16>( EMTPObjectPropCodeName ), *nameString );
+    aData->AppendL( newElement );
+    CleanupStack::Pop( nameString );
+    PRINTF0( "<CMediaMtpDataProviderTester::SetObjectPropListReceiveDataL" );
+    }
+
+TInt CMediaMtpDataProviderTester::DeleteObjectL_checkresults(
+        MMTPObjectMgr& aObjectManager )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::DeleteObjectL_checkresults" );
+    TInt result = KErrNone;
+    // check that everything has been deleted from the file system
+    if ( BaflUtils::FileExists( iFsSession, KTestObjectPath1 ) ) 
+        {
+        PRINTE0( "Test file 1 was not deleted successfully" );
+        result = KErrGeneral;
+        }
+    if ( BaflUtils::FileExists( iFsSession, KTestObjectPath2 ) ) 
+        {
+        PRINTE0( "Test file 2 was not deleted successfully" );
+        result = KErrGeneral;
+        }
+    if ( BaflUtils::FileExists( iFsSession, KTestObjectPath3 ) ) 
+        {
+        PRINTE0( "Test file 3 was not deleted successfully" );
+        result = KErrGeneral;
+        }
+    PRINTF1( ">CMediaMtpDataProviderTester::DeleteObjectL_checkresults result = %d", result );
+    return result;
+    }
+
+TBool CMediaMtpDataProviderTester::CopyObjectL_prepare(
+        TMTPTypeRequest& aRequest )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::CopyObjectL_prepare" );
+    TBool result = ETrue;
+    TUint32 storageId = KTestStorageId; // physical storage
+    aRequest.SetUint32( TMTPTypeRequest::ERequestParameter2, storageId );
+    PRINTF1( "<CMediaMtpDataProviderTester::CopyObjectL_prepare result = %d", result );
+    return result;
+    }
+
+TInt CMediaMtpDataProviderTester::CopyObjectL_checkresults(
+        const CMTPObjectMetaData* aMetaData )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::CopyObjectL_checkresults" );
+    TInt result = KErrNone;
+    if ( !BaflUtils::FileExists( iFsSession, KCopyTestObjectPath ) )
+        {
+        PRINTE0( "Copied file does not exist" );
+        result = KErrGeneral;
+        }
+    else
+        {
+        TEntry entry;
+        result = iFsSession.Entry( KCopyTestObjectPath, entry );
+        if ( result != KErrNone )
+            {
+            PRINTE1( "Could not read file entry, error: %d", result );
+            }
+        else
+            {
+            if ( entry.iSize != KCopyTestFileSize )
+                {
+                PRINTE2( "Copied file size is incorrect: %d != %d", entry.iSize, KCopyTestFileSize );
+                result = KErrGeneral;
+                }
+            }
+        }
+    
+    if ( aMetaData )
+        {
+        PRINTV1( "Suid: %S", &aMetaData->DesC( CMTPObjectMetaData::ESuid ) );
+        
+        if ( aMetaData->Uint( CMTPObjectMetaData::EParentHandle ) != KMTPHandleNoParent )
+            {
+            PRINTV1( "Parent handle = %d", aMetaData->Uint( CMTPObjectMetaData::EParentHandle ) );
+            //TODO: parent handles don't work yet properly
+            //result = KErrGeneral;
+            }
+        
+        if ( aMetaData->Int( CMTPObjectMetaData::EParentId ) != KErrNotFound )
+            {
+            PRINTV1( "Parent id = %d", aMetaData->Int( CMTPObjectMetaData::EParentId ) );
+            //TODO: parent ids don't work yet properly
+            //result = KErrGeneral;
+            }
+        if ( aMetaData->Uint( CMTPObjectMetaData::EDataProviderId ) != 0 )
+            {
+            PRINTV1( "Dataprovider id = %d", aMetaData->Uint( CMTPObjectMetaData::EDataProviderId ) );
+            //TODO: not sure if this is necessary
+            //result = KErrGeneral;
+            }
+        if ( aMetaData->Uint( CMTPObjectMetaData::EFormatCode ) != EMTPFormatCodeMP3 )
+            {
+            PRINTV1( "Format code = %d", aMetaData->Uint( CMTPObjectMetaData::EFormatCode ) );
+            result = KErrGeneral;
+            }
+        if ( aMetaData->Uint( CMTPObjectMetaData::EStorageId ) != KTestStorageId )
+            {
+            PRINTV1( "StorageId = %d ", aMetaData->Uint( CMTPObjectMetaData::EStorageId ) );
+            result = KErrGeneral;
+            }
+        if ( ( aMetaData->DesC( CMTPObjectMetaData::ESuid ) ).Match( KCopyTestObjectPath ) != 0 )
+            {
+            PRINTV0( "Copied object path incorrect" );
+            result = KErrGeneral;
+            }
+        }
+    else
+        {
+        PRINTV0( "Object metadata not received correctly" );
+        result = KErrArgument;
+        }
+    PRINTF1( "<CMediaMtpDataProviderTester::CopyObjectL_checkresults result = %d", result );
+    return result;
+    }
+
+TBool CMediaMtpDataProviderTester::MoveObjectL_prepare(
+        TMTPTypeRequest& aRequest )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::MoveObjectL_prepare" );
+    TBool result = ETrue;
+    TUint32 storageId = KTestStorageId; // physical storage
+    aRequest.SetUint32( TMTPTypeRequest::ERequestParameter2, storageId );
+    PRINTF1( "<CMediaMtpDataProviderTester::MoveObjectL_prepare result = %d", result );
+    return result;
+    }
+
+TInt CMediaMtpDataProviderTester::MoveObjectL_checkresults( const CMTPObjectMetaData* aMetaData )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::MoveObjectL_checkresults" );
+    TInt result = KErrNone;
+    if ( BaflUtils::FileExists( iFsSession, KMoveTestObjectOldPath ) )
+        {
+        PRINTE0( "Moved file still exists in original location" );
+        result = KErrGeneral;
+        }
+    if ( !BaflUtils::FileExists( iFsSession, KMoveTestObjectNewPath ) )
+        {
+        PRINTE0( "Moved file does not exist in new location" );
+        result = KErrGeneral;
+        }
+    else
+        {
+        TEntry entry;
+        result = iFsSession.Entry( KMoveTestObjectNewPath, entry );
+        if ( result != KErrNone )
+            {
+            PRINTE1( "Could not read file entry, error: %d", result );
+            }
+        else
+            {
+            if ( entry.iSize != KMoveTestFileSize )
+                {
+                PRINTE2( "Moved file size is incorrect: %d != %d", entry.iSize, KCopyTestFileSize );
+                result = KErrGeneral;
+                }
+            }
+        }
+    
+    if ( aMetaData )
+        {
+        PRINTV1( "Suid: %S", &aMetaData->DesC( CMTPObjectMetaData::ESuid ) );
+        
+        if ( aMetaData->Uint( CMTPObjectMetaData::EParentHandle ) != KMTPHandleNoParent )
+            {
+            PRINTV1( "Parent handle = %d", aMetaData->Uint( CMTPObjectMetaData::EParentHandle ) );
+            //TODO: parent handles don't work yet properly
+            //result = KErrGeneral;
+            }
+     
+        if ( aMetaData->Int( CMTPObjectMetaData::EParentId ) != KErrNotFound )
+            {
+            PRINTV1( "Parent id = %d", aMetaData->Int( CMTPObjectMetaData::EParentId ) );
+            //TODO: parent ids don't work yet properly
+            //result = KErrGeneral;
+            }
+        if ( aMetaData->Uint( CMTPObjectMetaData::EDataProviderId ) != 0 )
+            {
+            PRINTV1( "Dataprovider id = %d", aMetaData->Uint( CMTPObjectMetaData::EDataProviderId ) );
+            //TODO: not sure if this is necessary
+            //result = KErrGeneral;
+            }
+        if ( aMetaData->Uint( CMTPObjectMetaData::EFormatCode ) != EMTPFormatCodeMP3 )
+            {
+            PRINTV1( "Format code = %d", aMetaData->Uint( CMTPObjectMetaData::EFormatCode ) );
+            result = KErrGeneral;
+            }
+        if ( aMetaData->Uint( CMTPObjectMetaData::EStorageId ) != KTestStorageId )
+            {
+            PRINTV1( "StorageId = %d ", aMetaData->Uint( CMTPObjectMetaData::EStorageId ) );
+            result = KErrGeneral;
+            }
+        if ( ( aMetaData->DesC( CMTPObjectMetaData::ESuid ) ).Match( KMoveTestObjectNewPath ) != 0 )
+            {
+            PRINTV0( "Copied object path incorrect" );
+            result = KErrGeneral;
+            }
+        }
+    else
+        {
+        PRINTV0( "Object metadata not received correctly" );
+        result = KErrArgument;
+        }
+    PRINTF1( "<CMediaMtpDataProviderTester::MoveObjectL_checkresults result = %d", result );
+    return KErrNone;
+    }
+
+TInt CMediaMtpDataProviderTester::GetPartialObjectL_checkresults( CMTPTypeFile *aObjectInfo )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::GetPartialObjectL_checkresults" );
+    // just check the handle is correct, based on the size...
+    TInt result = KErrNone;
+    if ( aObjectInfo ) 
+        {
+        TInt size = aObjectInfo->Size();
+        __TRACE( KPrint, ( _L("Received object size: %d"), size ) );
+        if ( size != KTestFileSize )
+            {
+            __TRACE( KError, ( _L("Wrong received object size: %d != %d" ), KTestFileSize, size ) );
+            result =  KErrGeneral;
+            }
+        aObjectInfo->File().Close();
+        }
+    else
+        {
+        __TRACE( KError, ( _L("Object info not received" ) ) );
+        result = KErrArgument;
+        }
+    PRINTF1( "<CMediaMtpDataProviderTester::GetPartialObjectL_checkresults result = %d", result );
+    return result;    
+    }
+
+TBool CMediaMtpDataProviderTester::RenameObjectL_prepare( TMTPNotificationParamsHandle& aParam )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::RenameObjectL_prepare" );
+    TBool result = ETrue;
+    TFileName fileName( KRenameObjectName );
+    aParam.iHandleId = KTestDirHandle;
+    aParam.iFileName = fileName;
+    
+    TInt moveResult = iFileMan->Move( KTestDirPath, KRenameObjectPath,
+            CFileMan::ERecurse );
+    if ( moveResult != KErrNone )
+        {
+        PRINTE1( "Moving directory failed with error %d", moveResult );
+        }
+    CMTPObjectMetaData* metadata = CMTPObjectMetaData::NewLC();
+    iTestObserver->ObjectMgr().ObjectL( KTestDirPath, *metadata );
+    metadata->SetDesCL( CMTPObjectMetaData::ESuid, KRenameObjectPath );
+    iTestObserver->ObjectMgr().ModifyObjectL( *metadata );
+    CleanupStack::PopAndDestroy( metadata );
+    PRINTF1( "<CMediaMtpDataProviderTester::RenameObjectL_prepare result = %d", result );
+    return result;
+    }
+
+TInt CMediaMtpDataProviderTester::RenameObjectL_checkresults( const CMTPObjectMetaData* aMetaData )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::RenameObjectL_checkresults" );
+    TInt result = KErrNone;
+    
+    TMTPObjectMgrQueryParams queryParams ( KMTPStorageAll, KMTPFormatsAll, KMTPHandleNone );
+    RMTPObjectMgrQueryContext context;
+    RArray<TUint> handles;
+    CleanupClosePushL( handles );
+    
+    iTestObserver->ObjectMgr().GetObjectHandlesL( queryParams, context, handles );
+    context.Close();
+    TInt count = handles.Count();
+    PRINTV1( "Handle count: %d", count );
+    
+    CMTPObjectMetaData* metadata = CMTPObjectMetaData::NewLC();
+    for ( TInt i = 0; i < count; i++ )
+        {
+        TUint handle = handles[i];
+        iTestObserver->ObjectMgr().ObjectL( handle, *metadata );
+        TPtrC fileName = metadata->DesC( CMTPObjectMetaData::ESuid );
+        PRINTV1( "Handle: %d", handle );
+        PRINTV1( "File name: %S", &fileName );
+        }
+    CleanupStack::PopAndDestroy( 2 ); // metadata, handles
+    PRINTF1( "<CMediaMtpDataProviderTester::RenameObjectL_checkresults result = %d", result );
+    return result;
+    }
+
+TBool CMediaMtpDataProviderTester::GetObjectPropsSupportedL_prepare( TMTPTypeRequest& aRequest )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::GetObjectPropsSupportedL_prepare" );
+    TBool result = ETrue;
+    aRequest.SetUint32( TMTPTypeRequest::ERequestParameter1, EMTPFormatCodeMP3 );
+    PRINTF1( "<CMediaMtpDataProviderTester::GetObjectPropsSupportedL_prepare result = %d", result );
+    return result;
+    }
+
+TInt CMediaMtpDataProviderTester::GetObjectPropsSupportedL_checkresults( const CMTPTypeArray* aObjectProps )
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::GetObjectPropsSupportedL_checkresults" );
+    TInt result = KErrNone;
+    TInt count = aObjectProps->NumElements();
+    PRINTV1( "Object props found: %d", count );
+    PRINTF1( "<CMediaMtpDataProviderTester::GetObjectPropsSupportedL_checkresults result = %d", result );
+    return result;
+    }
+
+TBool CMediaMtpDataProviderTester::ProcessRequestIllegalIdL_prepare(TInt aOpCode) 
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::ProcessRequestIllegalIdL_prepare" );
+    // EMTPOpCodeGetObjectPropValue cannot be tested with the invalid session id, as the object
+    // must exist or the data provider fails in __ASSERT_DEBUG(aObjectInfo, Panic(EMTPPictureDpObjectNull));
+    TBool result = ETrue;
+    if ( aOpCode == EMTPOpCodeGetObjectPropValue )
+        {
+        result = EFalse;
+        }
+    PRINTF1( "<CMediaMtpDataProviderTester::ProcessRequestIllegalIdL_prepare result = %d", result );
+    return result;
+    }
+
+TInt CMediaMtpDataProviderTester::ProcessRequestIllegalIdL_checkresults(TInt aOpCode, TInt aResponseCode)
+    {
+    PRINTF0( ">CMediaMtpDataProviderTester::ProcessRequestIllegalIdL_checkresults" );
+    TInt result = KErrGeneral;
+    switch (aOpCode)
+        {
+        case EMTPOpCodeGetObjectInfo:
+        case EMTPOpCodeGetObject:
+        case EMTPOpCodeGetPartialObject:
+        case EMTPOpCodeGetThumb:
+        case EMTPOpCodeDeleteObject:
+        case EMTPOpCodeMoveObject:
+        case EMTPOpCodeCopyObject:
+        case EMTPOpCodeGetObjectPropsSupported:
+        case EMTPOpCodeGetObjectPropList:
+        case EMTPOpCodeGetObjectReferences:
+            if (aResponseCode == EMTPRespCodeSessionNotOpen) 
+                {
+                result = KErrNone;
+                }
+            break;
+        case EMTPOpCodeSendObjectInfo:
+        case EMTPOpCodeSendObject:
+        case EMTPOpCodeSetObjectPropValue:
+        case EMTPOpCodeSetObjectPropList:
+        case EMTPOpCodeSendObjectPropList:
+        case EMTPOpCodeSetObjectReferences:
+            if (aResponseCode == 0) 
+                 {
+                 result = KErrNone;
+                 }   
+            break;
+        case EMTPOpCodeGetObjectPropDesc:
+            if (aResponseCode == EMTPRespCodeInvalidObjectFormatCode) 
+                 {
+                 result = KErrNone;
+                 }
+            break;
+        case EMTPOpCodeGetDeviceInfo:
+            if (aResponseCode == EMTPRespCodeInvalidTransactionID) 
+                 {
+                 result = KErrNone;
+                 }
+            break;            
+        default:
+            result = KErrNone;
+            break;
+        }
+    PRINTF1( "<CMediaMtpDataProviderTester::ProcessRequestIllegalIdL_checkresults result = %d", result );
+    return result;
+    }