diff -r afc583cfa176 -r da2ae96f639b contentmgmt/referencedrmagent/tcaf/source/Consumerstep.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/contentmgmt/referencedrmagent/tcaf/source/Consumerstep.cpp Mon Oct 12 10:17:04 2009 +0300 @@ -0,0 +1,2749 @@ +/* +* Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + + +#include +#include +#include +#include +#include "cafserver.h" +#include "bitset.h" +#include "Consumerstep.h" +#include "attributeset.h" +#include "stringattributeset.h" +#include +#include +#include + +using namespace ContentAccess; + +const TInt KCafTestMaxDataTypeLength = 255; +const TInt KCafTestSecToMS = 1000; + +_LIT(KCDataThreadSemaphore, "CData_Thread_Test"); + +/* + * Step1 compares an agent 'size' call with that obtained by RFile + * + */ + +CCAFSizeStep::~CCAFSizeStep() + { + } + +CCAFSizeStep::CCAFSizeStep(CCAFServer& aParent) +: iParent(aParent) + { + SetTestStepName(KCAFSizeStep); + } + +TVerdict CCAFSizeStep::doTestStepL() + { + __UHEAP_MARK; + + SetTestStepResult(EInconclusive); + + INFO_PRINTF1(_L("Basic Open Content Test")); + + TPtrC uri1; + TPtrC uri2; + GetStringFromConfig(ConfigSection(),_L("URI1"),uri1); + GetStringFromConfig(ConfigSection(),_L("URI2"),uri2); + + INFO_PRINTF2(_L("Creating CContent object with uri: %S"), &uri1); + CContent* content = CContent::NewLC(uri1); + INFO_PRINTF1(_L("Creating CData object from content")); + + CData* data = content->OpenContentL(EPeek); + CleanupStack::PushL(data); + + TInt size = 0; + data->DataSizeL(size); + INFO_PRINTF2(_L("Size of content from caf CContent::OpenContentL(): %d"),size); + CleanupStack::PopAndDestroy(data); + CleanupStack::PopAndDestroy(content); + + INFO_PRINTF2(_L("Creating CData object with uri: %S"), &uri1); + TInt size1 = 0; + + TBool withoutIntent; + if (!GetBoolFromConfig(ConfigSection(),_L("WITHOUTINTENT"),withoutIntent)) + { + INFO_PRINTF1(_L("With Intent")); + data = CData::NewL(TVirtualPathPtr(uri1), EPeek, EContentShareReadOnly); + } + else + { + INFO_PRINTF1(_L("Without Intent")); + data = CData::NewL(TVirtualPathPtr(uri1), EContentShareReadOnly); + data->SetProperty(EAgentPropertyAgentUI, 0); + User::LeaveIfError(data->EvaluateIntent(EPeek)); + } + + CleanupStack::PushL(data); + data->DataSizeL(size1); + INFO_PRINTF2(_L("Size of content from caf CData::NewL(): %d"),size1); + CleanupStack::PopAndDestroy(data); + + INFO_PRINTF2(_L("Opening standard RFile interface with uri: %S"),&uri2); + RFile file; + User::LeaveIfError(file.Open(iParent.Fs(), uri2, EFileRead)); + + TInt size2; + file.Size(size2); + file.Close(); + + INFO_PRINTF2(_L("Size of content from f32: %d"),size2); + + if(size == size2 && size == size1) + { + SetTestStepResult(EPass); + } + else + { + SetTestStepResult(EFail); + } + + __UHEAP_MARKEND; + return TestStepResult(); + } + +#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API +/* + * This is the 64bit version of CCAFSizeStep + */ + +CCAFSizeStep64::~CCAFSizeStep64() + { + } + +CCAFSizeStep64::CCAFSizeStep64(CCAFServer& aParent) +: iParent(aParent) + { + SetTestStepName(KCAFSizeStep); + } + +TVerdict CCAFSizeStep64::doTestStepL() + { + __UHEAP_MARK; + + SetTestStepResult(EInconclusive); + + INFO_PRINTF1(_L("Basic Open Content Test")); + + TPtrC uri1; + TPtrC uri2; + GetStringFromConfig(ConfigSection(),_L("URI1"),uri1); + GetStringFromConfig(ConfigSection(),_L("URI2"),uri2); + + INFO_PRINTF2(_L("Creating CContent object with uri: %S"), &uri1); + CContent* content = CContent::NewLC(uri1); + INFO_PRINTF1(_L("Creating CData object from content")); + + CData* data = content->OpenContentL(EPeek); + CleanupStack::PushL(data); + + TInt64 size = 0; + data->DataSize64L(size); + INFO_PRINTF2(_L("Size of content from caf CContent::OpenContentL(): %Ld"),size); + CleanupStack::PopAndDestroy(data); + CleanupStack::PopAndDestroy(content); + + INFO_PRINTF2(_L("Creating CData object with uri: %S"), &uri1); + TInt64 size1 = 0; + + TBool withoutIntent; + if (!GetBoolFromConfig(ConfigSection(),_L("WITHOUTINTENT"),withoutIntent)) + { + INFO_PRINTF1(_L("With Intent")); + data = CData::NewL(TVirtualPathPtr(uri1), EPeek, EContentShareReadOnly); + } + else + { + INFO_PRINTF1(_L("Without Intent")); + data = CData::NewL(TVirtualPathPtr(uri1), EContentShareReadOnly); + data->SetProperty(EAgentPropertyAgentUI, 0); + User::LeaveIfError(data->EvaluateIntent(EPeek)); + } + + CleanupStack::PushL(data); + data->DataSize64L(size1); + INFO_PRINTF2(_L("Size of content from caf CData::NewL(): %Ld"),size1); + CleanupStack::PopAndDestroy(data); + + INFO_PRINTF2(_L("Opening standard RFile interface with uri: %S"),&uri2); + RFile64 file; + User::LeaveIfError(file.Open(iParent.Fs(), uri2, EFileRead)); + + TInt64 size2; + file.Size(size2); + file.Close(); + + INFO_PRINTF2(_L("Size of content from f32: %Ld"),size2); + + if(size == size2 && size == size1) + { + SetTestStepResult(EPass); + } + else + { + SetTestStepResult(EFail); + } + + __UHEAP_MARKEND; + return TestStepResult(); + } +#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + +/* + * This step compares a seek and read using CAF with that using RFile + * + */ + +CCAFSeekReadStep::~CCAFSeekReadStep() + { + } + +CCAFSeekReadStep::CCAFSeekReadStep(CCAFServer& aParent) +: iParent(aParent) + { + SetTestStepName(KCAFSeekReadStep); + } + +void CCAFSeekReadStep::StandardCheckReturnValue(TInt aReturnValue) + { + if (aReturnValue != KErrNone) + { + INFO_PRINTF2(_L("ERROR Unexpected return value: %d"),aReturnValue); + SetTestStepResult(EFail); + } + } +TVerdict CCAFSeekReadStep::doTestStepL() + { + SetTestStepResult(EInconclusive); + + TBuf8<2> buf1; + TBuf8<2> buf2; + TRequestStatus status; + + __UHEAP_MARK; + INFO_PRINTF1(_L("Basic Open Content Test")); + + TPtrC uri1; + TPtrC uri2; + GetStringFromConfig(ConfigSection(),_L("URI1"),uri1); + GetStringFromConfig(ConfigSection(),_L("URI2"),uri2); + + INFO_PRINTF2(_L("Creating content object with uri: %S"), &uri1); + CContent* content = CContent::NewLC(uri1); + + INFO_PRINTF1(_L("Creating data object from content")); + CData* data = content->OpenContentL(EPeek); + + // don't need CContent any more + CleanupStack::PopAndDestroy(content); + CleanupStack::PushL(data); + + // Now, open the same file using RFile + RFile file; + INFO_PRINTF2(_L("Opening standard RFile interface with uri: %S"),&uri2); + User::LeaveIfError(file.Open(iParent.Fs(), uri2, EFileRead | EFileShareReadersOnly)); + CleanupClosePushL(file); + + TInt size = 0; + file.Size(size); + INFO_PRINTF2(_L("Size of content from f32: %d"),size); + + // Seek and read from start using both CAF and RFile + TInt pos1 = size/4; + data->Seek(ESeekStart, pos1); + TInt pos2 = size/4; + file.Seek(ESeekStart, pos2); + data->Read(buf1); + file.Read(buf2); + INFO_PRINTF2(_L("Position from ESeekStart test using CData: %d"), pos1); + INFO_PRINTF2(_L("Position from ESeekStart test using RFile: %d"), pos2); + if (buf1 != buf2 || pos1 != pos2 || pos1 != size/4) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // set the location within the file then retrieve the current location within the file + pos1=0; + pos2=0; + data->Seek(ESeekCurrent, pos1); + file.Seek(ESeekCurrent, pos2); + + INFO_PRINTF2(_L("Current position using CData: %d"), pos1); + INFO_PRINTF2(_L("Current position using RFile: %d"), pos2); + + if(pos1 != pos2 || pos1 != (size/4 + buf1.Length())) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // Seek and read from current using both CAF and RFile + pos1 = size/4; + data->Seek(ESeekCurrent, pos1); + pos2 = size/4; + file.Seek(ESeekCurrent, pos2); + data->Read(buf1); + file.Read(buf2); + INFO_PRINTF2(_L("Position from ESeekCurrent test using CData: %d"), pos1); + INFO_PRINTF2(_L("Position from ESeekCurrent test using RFile: %d"), pos2); + if (buf1 != buf2 || pos1 != pos2 || pos1 != (size/2 + buf1.Length())) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // Seek and read from end using both CAF and RFile + pos1 = -size/4; + data->Seek(ESeekEnd, pos1); + pos2 = -size/4; + file.Seek(ESeekEnd, pos2); + data->Read(buf1); + file.Read(buf2); + INFO_PRINTF2(_L("Position from ESeekEnd test using CData: %d"), pos1); + INFO_PRINTF2(_L("Position from ESeekEnd test using RFile: %d"), pos2); + if (buf1 != buf2 || pos1 != pos2 || pos1 != (size - size/4)) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // Test other overloaded forms of CData::Read + + // Read only 1 byte using both CAF and RFile + pos1 = size/4; + data->Seek(ESeekStart, pos1); + pos2 = size/4; + file.Seek(ESeekStart, pos2); + data->Read(buf1,1); + file.Read(buf2,1); + INFO_PRINTF2(_L("Data Length from CData::Read(TDesC& ,TInt Length) : %d"), buf1.Length()); + INFO_PRINTF2(_L("Data Length from RFile::Read(TDesC& , TInt Length): %d"), buf2.Length()); + + pos1=0; + pos2=0; + data->Seek(ESeekCurrent, pos1); + file.Seek(ESeekCurrent,pos2); + if (buf1 != buf2 || pos1 != pos2 || buf1.Length() != buf2.Length()) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // Read asynchronously using both CAF and RFile + INFO_PRINTF1(_L("Asynchronous read from CAF and RFile")); + pos1 = size/4; + data->Seek(ESeekStart, pos1); + pos2 = size/4; + file.Seek(ESeekStart, pos2); + status = KRequestPending; + data->Read(buf1,status); + User::WaitForRequest(status); + status = KRequestPending; + file.Read(buf2,status); + User::WaitForRequest(status); + INFO_PRINTF2(_L("Data length from CData::Read(TDesC& ,TRequestStatus& aStatus): %d"), buf1.Length()); + INFO_PRINTF2(_L("Data length from RFile::Read(TDesC& , TRequestStatus& aStatus): %d"), buf2.Length()); + + pos1=0; + pos2=0; + data->Seek(ESeekCurrent, pos1); + file.Seek(ESeekCurrent,pos2); + if (buf1 != buf2 || pos1 != pos2 || buf1.Length() != buf2.Length()) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // Read only 1 byte asynchronously using both CAF and RFile + INFO_PRINTF1(_L("Asynchronous read of 1 byte from CAF and RFile")); + pos1 = size/4; + data->Seek(ESeekStart, pos1); + pos2 = size/4; + file.Seek(ESeekStart, pos2); + status = KRequestPending; + data->Read(buf1,1,status); + User::WaitForRequest(status); + status = KRequestPending; + file.Read(buf2,1, status); + User::WaitForRequest(status); + INFO_PRINTF2(_L("Data Length from CData::Read(TDesC& ,TInt Length, TRequestStatus aStatus) : %d"), buf1.Length()); + INFO_PRINTF2(_L("Data Length from RFile::Read(TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf2.Length()); + + pos1=0; + pos2=0; + data->Seek(ESeekCurrent, pos1); + file.Seek(ESeekCurrent,pos2); + if (buf1 != buf2 || pos1 != pos2 || buf1.Length() != buf2.Length()) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // read past EOF + pos1 = size+1; + pos2 = size+1; + data->Seek(ESeekStart, pos1); + file.Seek(ESeekStart, pos2); + data->Read(buf1); + file.Read(buf2); + + if(buf1.Length() != 0 || buf1.Length() != 0) + { + INFO_PRINTF1(_L("ERROR data read past EOF")); + SetTestStepResult(EFail); + } + + + // Read asynchronously supplying an offset using both CAF and RFile + TInt err; + INFO_PRINTF1(_L("Asynchronous read of 1 byte from CAF and RFile supplying an offset within the file")); + pos1 = size/4; + pos2 = size/4; + status = KRequestPending; + err = data->Read(pos1,buf1,1,status); + + StandardCheckReturnValue(err); + + User::WaitForRequest(status); + status = KRequestPending; + file.Read(pos2, buf2,1, status); + User::WaitForRequest(status); + INFO_PRINTF2(_L("Data Length from CData::Read(TInt aPos, TDesC& , TInt Length, TRequestStatus aStatus) : %d"), buf1.Length()); + INFO_PRINTF2(_L("Data Length from RFile::Read(TInt aPos, TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf2.Length()); + + pos1=0; + pos2=0; + data->Seek(ESeekCurrent, pos1); + file.Seek(ESeekCurrent,pos2); + if (buf1 !=buf2 || pos1 != pos2 || buf1.Length() != buf2.Length()) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // Check asynchronous cancellation + err = 0; + INFO_PRINTF1(_L("Asynchronous read cancellation using both CAF and RFile with an offset within the file")); + pos1 = size/4; + pos2 = size/4; + status = KRequestPending; + err = data->Read(pos1,buf1,1,status); + StandardCheckReturnValue(err); + data->ReadCancel(status); + User::WaitForRequest(status); + TRequestStatus status2(KRequestPending); + file.Read(pos2, buf2,1, status2); + file.ReadCancel(); + User::WaitForRequest(status2); + INFO_PRINTF3(_L("Data Length from CData::Read(TInt aPos, TDesC& , TInt Length, TRequestStatus aStatus) : %d, status is %d"), buf1.Length(), status.Int()); + INFO_PRINTF3(_L("Data Length from RFile::Read(TInt aPos, TDesC& , TInt Length, TRequestStatus aStatus): %d, status is %d"), buf2.Length(), status2.Int()); + if (status.Int() != status2.Int() || buf1 !=buf2 || pos1 != pos2 || buf1.Length() != buf2.Length()) + { + INFO_PRINTF1(_L("ERROR status, buffers or position do not match")); + SetTestStepResult(EFail); + } + + // read past EOF + pos1 = size+1; + pos2 = size+1; + status = KRequestPending; + data->Read(pos1,buf1,1,status); + StandardCheckReturnValue(err); + User::WaitForRequest(status); + status = KRequestPending; + file.Read(pos2,buf2,1,status); + User::WaitForRequest(status); + + if(buf1.Length() != 0 || buf1.Length() != 0) + { + INFO_PRINTF1(_L("ERROR data read past EOF")); + SetTestStepResult(EFail); + } + + // read over the length of the buffer + INFO_PRINTF1(_L("Asynchronous read of 5 bytes from CAF and RFile supplying an offset within the file")); + pos1 = size/4; + pos2 = size/4; + status = KRequestPending; + err = data->Read(pos1,buf1,5,status); + StandardCheckReturnValue(err); + User::WaitForRequest(status); + if(status.Int()!=KErrOverflow) + { + INFO_PRINTF2(_L("ERROR Unexpected status returned: %d"),status.Int()); + SetTestStepResult(EFail); + } + status = KRequestPending; + file.Read(pos2, buf2,5, status); + User::WaitForRequest(status); + INFO_PRINTF2(_L("Data Length from CData::Read(TInt aPos, TDesC& , TInt Length, TRequestStatus aStatus) : %d"), buf1.Length()); + INFO_PRINTF2(_L("Data Length from RFile::Read(TInt aPos, TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf2.Length()); + + if (buf1 !=buf2 || buf1.Length() != buf2.Length()) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + // read negative position this should return KErrArgument, dont supply -ve pos to RFile as will panic test + INFO_PRINTF1(_L("Asynchronous read from CAF supplying a negative offset within the file")); + pos1 = -1; + status = KRequestPending; + err = data->Read(pos1,buf1,5,status); + if(err!=KErrArgument) + { + INFO_PRINTF2(_L("ERROR Unexpected return value: %d"),err); + SetTestStepResult(EFail); + } + + // Read asynchronously supplying an offset of 0 and a length greater than size of file using both CAF and RFile + INFO_PRINTF1(_L("Asynchronous read of length greater than size of file from CAF and RFile supplying an offset of 0 within the file")); + TBuf8<256> buf3; + TBuf8<256> buf4; + pos1 = 0; + pos2 = 0; + status = KRequestPending; + err = data->Read(pos1,buf3,size+1,status); + StandardCheckReturnValue(err); + User::WaitForRequest(status); + status = KRequestPending; + file.Read(pos2, buf4,size+1, status); + User::WaitForRequest(status); + INFO_PRINTF2(_L("Data Length from CData::Read(TInt aPos, TDesC& , TInt Length, TRequestStatus aStatus) : %d"), buf3.Size()); + INFO_PRINTF2(_L("Data Length from RFile::Read(TInt aPos, TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf4.Size()); + + pos1=0; + pos2=0; + data->Seek(ESeekCurrent, pos1); + file.Seek(ESeekCurrent,pos2); + if (buf3 != buf4 || pos1 != pos2 || buf3.Length() != buf4.Length() || pos1 != size || + pos2 != size || buf3.Size() != pos1 || buf4.Size() != pos2) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // Read asynchronously supplying an offset of size/4 and a length greater than size of file using both CAF and RFile + INFO_PRINTF1(_L("Asynchronous read of length greater than size of file from CAF and RFile supplying an offset within the file")); + pos1 = size/4; + pos2 = size/4; + status = KRequestPending; + err = data->Read(pos1,buf3,size+1,status); + StandardCheckReturnValue(err); + User::WaitForRequest(status); + status = KRequestPending; + file.Read(pos2, buf4,size+1, status); + User::WaitForRequest(status); + INFO_PRINTF2(_L("Data Length from CData::Read(TInt aPos, TDesC& , TInt Length, TRequestStatus aStatus) : %d"), buf3.Size()); + INFO_PRINTF2(_L("Data Length from RFile::Read(TInt aPos, TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf4.Size()); + + pos1=0; + pos2=0; + data->Seek(ESeekCurrent, pos1); + file.Seek(ESeekCurrent,pos2); + if (buf3 != buf4 || pos1 != pos2 || buf3.Size() != buf4.Size() || pos1 != size || pos2 != size) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + CleanupStack::PopAndDestroy(2, data); + + __UHEAP_MARKEND; + + if (TestStepResult() != EFail) + { + SetTestStepResult(EPass); + } + + return TestStepResult(); + } + + +#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API +/* + * This is the 64bit version of CCAFSeekReadStep. +*/ + +CCAFSeekReadStep64::~CCAFSeekReadStep64() + { + } + +CCAFSeekReadStep64::CCAFSeekReadStep64(CCAFServer& aParent) +: iParent(aParent) + { + SetTestStepName(KCAFSeekReadStep); + } + +void CCAFSeekReadStep64::StandardCheckReturnValue(TInt aReturnValue) + { + if (aReturnValue != KErrNone) + { + INFO_PRINTF2(_L("ERROR Unexpected return value: %d"),aReturnValue); + SetTestStepResult(EFail); + } + } +TVerdict CCAFSeekReadStep64::doTestStepL() + { + SetTestStepResult(EInconclusive); + + TBuf8<2> buf1; + TBuf8<2> buf2; + TRequestStatus status; + + __UHEAP_MARK; + INFO_PRINTF1(_L("Basic Open Content Test")); + + TPtrC uri1; + TPtrC uri2; + GetStringFromConfig(ConfigSection(),_L("URI1"),uri1); + GetStringFromConfig(ConfigSection(),_L("URI2"),uri2); + + INFO_PRINTF2(_L("Creating content object with uri: %S"), &uri1); + CContent* content = CContent::NewLC(uri1); + + INFO_PRINTF1(_L("Creating data object from content")); + CData* data = content->OpenContentL(EPeek); + + // don't need CContent any more + CleanupStack::PopAndDestroy(content); + CleanupStack::PushL(data); + + // Now, open the same file using RFile + RFile64 file; + INFO_PRINTF2(_L("Opening standard RFile interface with uri: %S"),&uri2); + User::LeaveIfError(file.Open(iParent.Fs(), uri2, EFileRead | EFileShareReadersOnly)); + CleanupClosePushL(file); + + TInt64 size = 0; + file.Size(size); + INFO_PRINTF2(_L("Size of content from f32: %Ld"),size); + + // Seek and read from start using both CAF and RFile + TInt64 pos1 = size/4; + data->Seek64(ESeekStart, pos1); + //pos2 needs to be modified to TInt64 when file server supports 64bit + TInt64 pos2 = size/4; + file.Seek(ESeekStart, pos2); + data->Read(buf1); + file.Read(buf2); + INFO_PRINTF2(_L("Position from ESeekStart test using CData: %Ld"), pos1); + INFO_PRINTF2(_L("Position from ESeekStart test using RFile: %Ld"), pos2); + if (buf1 != buf2 || pos1 != pos2 || pos1 != size/4) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // set the location within the file then retrieve the current location within the file + pos1=0; + pos2=0; + data->Seek64(ESeekCurrent, pos1); + file.Seek(ESeekCurrent, pos2); + + INFO_PRINTF2(_L("Current position using CData: %Ld"), pos1); + INFO_PRINTF2(_L("Current position using RFile: %Ld"), pos2); + + if(pos1 != pos2 || pos1 != (size/4 + buf1.Length())) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // Seek and read from current using both CAF and RFile + pos1 = size/4; + data->Seek64(ESeekCurrent, pos1); + pos2 = size/4; + file.Seek(ESeekCurrent, pos2); + data->Read(buf1); + file.Read(buf2); + INFO_PRINTF2(_L("Position from ESeekCurrent test using CData: %Ld"), pos1); + INFO_PRINTF2(_L("Position from ESeekCurrent test using RFile: %Ld"), pos2); + if (buf1 != buf2 || pos1 != pos2 || pos1 != (size/2 + buf1.Length())) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // Seek and read from end using both CAF and RFile + pos1 = -size/4; + data->Seek64(ESeekEnd, pos1); + pos2 = -size/4; + file.Seek(ESeekEnd, pos2); + data->Read(buf1); + file.Read(buf2); + INFO_PRINTF2(_L("Position from ESeekEnd test using CData: %Ld"), pos1); + INFO_PRINTF2(_L("Position from ESeekEnd test using RFile: %Ld"), pos2); + if (buf1 != buf2 || pos1 != pos2 || pos1 != (size - size/4)) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // Test other overloaded forms of CData::Read + + // Read only 1 byte using both CAF and RFile + pos1 = size/4; + data->Seek64(ESeekStart, pos1); + pos2 = size/4; + file.Seek(ESeekStart, pos2); + data->Read(buf1,1); + file.Read(buf2,1); + INFO_PRINTF2(_L("Data Length from CData::Read(TDesC& ,TInt Length) : %d"), buf1.Length()); + INFO_PRINTF2(_L("Data Length from RFile::Read(TDesC& , TInt Length): %d"), buf2.Length()); + + pos1=0; + pos2=0; + data->Seek64(ESeekCurrent, pos1); + file.Seek(ESeekCurrent,pos2); + if (buf1 != buf2 || pos1 != pos2 || buf1.Length() != buf2.Length()) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // Read asynchronously using both CAF and RFile + INFO_PRINTF1(_L("Asynchronous read from CAF and RFile")); + pos1 = size/4; + data->Seek64(ESeekStart, pos1); + pos2 = size/4; + file.Seek(ESeekStart, pos2); + status = KRequestPending; + data->Read(buf1,status); + User::WaitForRequest(status); + status = KRequestPending; + file.Read(buf2,status); + User::WaitForRequest(status); + INFO_PRINTF2(_L("Data length from CData::Read(TDesC& ,TRequestStatus& aStatus): %d"), buf1.Length()); + INFO_PRINTF2(_L("Data length from RFile::Read(TDesC& , TRequestStatus& aStatus): %d"), buf2.Length()); + + pos1=0; + pos2=0; + data->Seek64(ESeekCurrent, pos1); + file.Seek(ESeekCurrent,pos2); + if (buf1 != buf2 || pos1 != pos2 || buf1.Length() != buf2.Length()) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // Read only 1 byte asynchronously using both CAF and RFile + INFO_PRINTF1(_L("Asynchronous read of 1 byte from CAF and RFile")); + pos1 = size/4; + data->Seek64(ESeekStart, pos1); + pos2 = size/4; + file.Seek(ESeekStart, pos2); + status = KRequestPending; + data->Read(buf1,1,status); + User::WaitForRequest(status); + status = KRequestPending; + file.Read(buf2,1, status); + User::WaitForRequest(status); + INFO_PRINTF2(_L("Data Length from CData::Read(TDesC& ,TInt Length, TRequestStatus aStatus) : %d"), buf1.Length()); + INFO_PRINTF2(_L("Data Length from RFile::Read(TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf2.Length()); + + pos1=0; + pos2=0; + data->Seek64(ESeekCurrent, pos1); + file.Seek(ESeekCurrent,pos2); + if (buf1 != buf2 || pos1 != pos2 || buf1.Length() != buf2.Length()) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // read past EOF + pos1 = size+1; + pos2 = size+1; + data->Seek64(ESeekStart, pos1); + file.Seek(ESeekStart, pos2); + data->Read(buf1); + file.Read(buf2); + + if(buf1.Length() != 0 || buf1.Length() != 0) + { + INFO_PRINTF1(_L("ERROR data read past EOF")); + SetTestStepResult(EFail); + } + + + // Read asynchronously supplying an offset using both CAF and RFile + TInt err; + INFO_PRINTF1(_L("Asynchronous read of 1 byte from CAF and RFile supplying an offset within the file")); + pos1 = size/4; + pos2 = size/4; + status = KRequestPending; + err = data->Read(pos1,buf1,1,status); + + StandardCheckReturnValue(err); + + User::WaitForRequest(status); + status = KRequestPending; + file.Read(pos2, buf2,1, status); + User::WaitForRequest(status); + INFO_PRINTF2(_L("Data Length from CData::Read(TInt64 aPos, TDesC& , TInt Length, TRequestStatus aStatus) : %d"), buf1.Length()); + INFO_PRINTF2(_L("Data Length from RFile::Read(TInt64 aPos, TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf2.Length()); + + pos1=0; + pos2=0; + data->Seek64(ESeekCurrent, pos1); + file.Seek(ESeekCurrent,pos2); + if (buf1 !=buf2 || pos1 != pos2 || buf1.Length() != buf2.Length()) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // Check asynchronous cancellation + err = 0; + INFO_PRINTF1(_L("Asynchronous read cancellation using both CAF and RFile with an offset within the file")); + pos1 = size/4; + pos2 = size/4; + status = KRequestPending; + err = data->Read(pos1,buf1,1,status); + StandardCheckReturnValue(err); + data->ReadCancel(status); + User::WaitForRequest(status); + TRequestStatus status2(KRequestPending); + file.Read(pos2, buf2,1, status2); + file.ReadCancel(); + User::WaitForRequest(status2); + INFO_PRINTF3(_L("Data Length from CData::Read(TInt64 aPos, TDesC& , TInt Length, TRequestStatus aStatus) : %d, status is %d"), buf1.Length(), status.Int()); + INFO_PRINTF3(_L("Data Length from RFile::Read(TInt64 aPos, TDesC& , TInt Length, TRequestStatus aStatus): %d, status is %d"), buf2.Length(), status2.Int()); + if (status.Int() != status2.Int() || buf1 !=buf2 || pos1 != pos2 || buf1.Length() != buf2.Length()) + { + INFO_PRINTF1(_L("ERROR status, buffers or position do not match")); + SetTestStepResult(EFail); + } + + // read past EOF + pos1 = size+1; + pos2 = size+1; + status = KRequestPending; + data->Read(pos1,buf1,1,status); + StandardCheckReturnValue(err); + User::WaitForRequest(status); + status = KRequestPending; + file.Read(pos2,buf2,1,status); + User::WaitForRequest(status); + + if(buf1.Length() != 0 || buf1.Length() != 0) + { + INFO_PRINTF1(_L("ERROR data read past EOF")); + SetTestStepResult(EFail); + } + + // read over the length of the buffer + INFO_PRINTF1(_L("Asynchronous read of 5 bytes from CAF and RFile supplying an offset within the file")); + pos1 = size/4; + pos2 = size/4; + status = KRequestPending; + err = data->Read(pos1,buf1,5,status); + StandardCheckReturnValue(err); + User::WaitForRequest(status); + if(status.Int()!=KErrOverflow) + { + INFO_PRINTF2(_L("ERROR Unexpected status returned: %d"),status.Int()); + SetTestStepResult(EFail); + } + status = KRequestPending; + file.Read(pos2, buf2,5, status); + User::WaitForRequest(status); + INFO_PRINTF2(_L("Data Length from CData::Read(TInt64 aPos, TDesC& , TInt Length, TRequestStatus aStatus) : %d"), buf1.Length()); + INFO_PRINTF2(_L("Data Length from RFile::Read(TInt64 aPos, TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf2.Length()); + + if (buf1 !=buf2 || buf1.Length() != buf2.Length()) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + // read negative position this should return KErrArgument, dont supply -ve pos to RFile as will panic test + INFO_PRINTF1(_L("Asynchronous read from CAF supplying a negative offset within the file")); + pos1 = -1; + status = KRequestPending; + err = data->Read(pos1,buf1,5,status); + if(err!=KErrArgument) + { + INFO_PRINTF2(_L("ERROR Unexpected return value: %d"),err); + SetTestStepResult(EFail); + } + + // Read asynchronously supplying an offset of 0 and a length greater than size of file using both CAF and RFile + INFO_PRINTF1(_L("Asynchronous read of length greater than size of file from CAF and RFile supplying an offset of 0 within the file")); + TBuf8<256> buf3; + TBuf8<256> buf4; + pos1 = 0; + pos2 = 0; + status = KRequestPending; + err = data->Read(pos1,buf3,size+1,status); + StandardCheckReturnValue(err); + User::WaitForRequest(status); + status = KRequestPending; + file.Read(pos2, buf4,size+1, status); + User::WaitForRequest(status); + INFO_PRINTF2(_L("Data Length from CData::Read(TInt64 aPos, TDesC& , TInt Length, TRequestStatus aStatus) : %d"), buf3.Size()); + INFO_PRINTF2(_L("Data Length from RFile::Read(TInt64 aPos, TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf4.Size()); + + pos1=0; + pos2=0; + data->Seek64(ESeekCurrent, pos1); + file.Seek(ESeekCurrent,pos2); + if (buf3 != buf4 || pos1 != pos2 || buf3.Length() != buf4.Length() || pos1 != size || + pos2 != size || buf3.Size() != pos1 || buf4.Size() != pos2) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // Read asynchronously supplying an offset of size/4 and a length greater than size of file using both CAF and RFile + INFO_PRINTF1(_L("Asynchronous read of length greater than size of file from CAF and RFile supplying an offset within the file")); + pos1 = size/4; + pos2 = size/4; + status = KRequestPending; + err = data->Read(pos1,buf3,size+1,status); + StandardCheckReturnValue(err); + User::WaitForRequest(status); + status = KRequestPending; + file.Read(pos2, buf4,size+1, status); + User::WaitForRequest(status); + INFO_PRINTF2(_L("Data Length from CData::Read(TInt64 aPos, TDesC& , TInt Length, TRequestStatus aStatus) : %d"), buf3.Size()); + INFO_PRINTF2(_L("Data Length from RFile::Read(TInt64 aPos, TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf4.Size()); + + pos1=0; + pos2=0; + data->Seek64(ESeekCurrent, pos1); + file.Seek(ESeekCurrent,pos2); + if (buf3 != buf4 || pos1 != pos2 || buf3.Size() != buf4.Size() || pos1 != size || pos2 != size) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + CleanupStack::PopAndDestroy(2, data); + + __UHEAP_MARKEND; + + if (TestStepResult() != EFail) + { + SetTestStepResult(EPass); + } + + return TestStepResult(); + } + +#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API +/* + * This step retrieves the attributes of a file using the CAF framework + * + */ + +CCAFAttributesStep::~CCAFAttributesStep() + { + } + +CCAFAttributesStep::CCAFAttributesStep(CCAFServer& aParent) : iParent(aParent) + { + SetTestStepName(KCAFAttributesStep); + } + + +TVerdict CCAFAttributesStep::doTestStepL() + { + CContent *content; + CAttribute *attrs; + TPtrC fileName; + TBool Protected; + TBool Forwardable; + + + TBool Value; + + SetTestStepResult(EFail); + + GetStringFromConfig(ConfigSection(),_L("filename"),fileName); + GetBoolFromConfig(ConfigSection(),_L("Protected"),Protected); + GetBoolFromConfig(ConfigSection(),_L("Forwardable"),Forwardable); + + + INFO_PRINTF2(_L("Check attributes of file: %S"), &fileName); + + __UHEAP_MARK; + + // Open a file and retrieve the attributes + content = CContent::NewLC(fileName); + attrs = content->NewAttributeL(ETrue); + CleanupStack::PushL(attrs); + + // Assume all the attributes are what we expect them to be + SetTestStepResult(EPass); + + Value = attrs->ResponseSet().IsSet(EIsProtected); + if(Value != Protected) + { + SetTestStepResult(EFail); + Protected ? INFO_PRINTF1(_L("File is Protected")) : INFO_PRINTF1(_L("File is not Protected")); + } + + Value = attrs->ResponseSet().IsSet(EIsForwardable); + if(Value != Forwardable) + { + SetTestStepResult(EFail); + Forwardable ? INFO_PRINTF1(_L("File is Forwardable")) : INFO_PRINTF1(_L("File is not Forwardable")); + } + + CleanupStack::PopAndDestroy(2, content); + + __UHEAP_MARKEND; + return TestStepResult(); + } + + +/* + * This step retrieves the string attributes of a file using the CAF framework + * + */ + +CCAFStringAttributesStep::~CCAFStringAttributesStep() + { + } + +CCAFStringAttributesStep::CCAFStringAttributesStep(CCAFServer& aParent) : iParent(aParent) + { + SetTestStepName(KCAFStringAttributesStep); + } + + +TVerdict CCAFStringAttributesStep::doTestStepL() + { + TInt expectedResult; + TInt attribute; + TPtrC expectedValue; + TBuf <256> value; //this will be used to test KErrOverFlow when transactionid is 257char long. + TInt result = KErrNone; + TPtrC uri; + TPtrC uniqueId; + + SetTestStepResult(EPass); + + GetIntFromConfig(ConfigSection(),_L("stringattribute"),attribute); + GetStringFromConfig(ConfigSection(),_L("uri"),uri); + GetStringFromConfig(ConfigSection(),_L("uniqueid"),uniqueId); + GetStringFromConfig(ConfigSection(),_L("value"),expectedValue); + GetIntFromConfig(ConfigSection(),_L("result"),expectedResult); + + __UHEAP_MARK; + CContent *content = CContent::NewLC(uri); + CData *data = content->OpenContentL(EPeek, uniqueId); + result = data->GetStringAttribute(attribute, value); + delete data; + if(result != expectedResult) + { + SetTestStepResult(EFail); + INFO_PRINTF3(_L("CData::GetStringAttribute() Expected result: %d, actual result: %d"), expectedResult, result); + } + if(value != expectedValue) + { + SetTestStepResult(EFail); + INFO_PRINTF3(_L("CData::GetStringAttribute() Expected value: %S, actual result: %S"), &expectedValue, &value); + } + + CleanupStack::PopAndDestroy(content); + + __UHEAP_MARKEND; + return TestStepResult(); + + } + + + + +/* + * Step reads from a CData from multiple threads + * + */ + +CCAFMultiThreadCDataStep::~CCAFMultiThreadCDataStep() + { + } + +CCAFMultiThreadCDataStep::CCAFMultiThreadCDataStep(CCAFServer& aParent) +: iParent(aParent) + { + SetTestStepName(KCAFMultiThreadCDataStep); + } + +TVerdict CCAFMultiThreadCDataStep::doTestStepL() + { + TBuf8<2> buf; + + __UHEAP_MARK; + _LIT(KCDataThread,"CData_Thread"); + + SetTestStepResult(EInconclusive); + + INFO_PRINTF1(_L("Multi Thread CData Test")); + + TPtrC uri; + GetStringFromConfig(ConfigSection(),_L("URI"),uri); + + INFO_PRINTF1(_L("Creating data object from content")); + CContent* content = CContent::NewLC(uri); + CData* data = content->OpenContentL(EPeek); + CleanupStack::PushL(data); + + TInt size, pos; + + // Create a mutex for communication between our thread and the new thread + RSemaphore threadSemaphore; + threadSemaphore.CreateGlobal(KCDataThreadSemaphore(), 1, EOwnerProcess); + threadSemaphore.Wait(); + + // fire up a new thread, stack size and heap size 8k, might need to be bigger in the future + RThread readerThread; + User::LeaveIfError(readerThread.Create(KCDataThread(),CCAFMultiThreadCDataStep::ReaderThreadEntry,8192, KMinHeapSize, 8192, (TAny *) data, EOwnerProcess)); + + // request notification of thread completion + TRequestStatus stat; + readerThread.Logon(stat); + readerThread.Resume(); + + data->DataSizeL(size); + pos = size/2; + data->Seek(ESeekStart,pos); + data->Read(buf); + + threadSemaphore.Wait(); // wait for thread function to run and signal the semaphore + threadSemaphore.Signal(); // finished with semaphore + threadSemaphore.Close(); // so close + + User::WaitForRequest(stat); // wait for thread to finish + TInt error=(readerThread.ExitType()==EExitPanic) ? KErrGeneral : stat.Int(); + User::LeaveIfError(error); + readerThread.Close(); // close the thread + + CleanupStack::PopAndDestroy(data); + CleanupStack::PopAndDestroy(content); + + __UHEAP_MARKEND; + + SetTestStepResult(EPass); + return TestStepResult(); + } + +TInt CCAFMultiThreadCDataStep::ReaderThreadEntry(TAny *aPtr) + { + TBuf8 <2> buf; + CData *data = reinterpret_cast (aPtr); + + // create a trap handler + CTrapCleanup* cleanup = CTrapCleanup::New(); + + RSemaphore threadSemaphore; + threadSemaphore.OpenGlobal(KCDataThreadSemaphore() ,EOwnerProcess); + + data->Read(buf); + threadSemaphore.Signal(); // allow original thread to continue + threadSemaphore.Close(); + + delete cleanup; + return KErrNone; + } + + +/* + * Obtains the mime type from a CData + * + */ + +CCAFMimeTypeCDataStep::~CCAFMimeTypeCDataStep() + { + } + +CCAFMimeTypeCDataStep::CCAFMimeTypeCDataStep(CCAFServer& aParent) +: iParent(aParent) + { + SetTestStepName(KCAFMimeTypeCDataStep); + } + +TVerdict CCAFMimeTypeCDataStep::doTestStepL() + { + __UHEAP_MARK; + + + SetTestStepResult(EFail); + + INFO_PRINTF1(_L("CData MimeType Test")); + + TPtrC uri; + TPtrC expectedMimeType; + TBool mimeTypeKnown=EFalse; + + // Load INI parameters + GetStringFromConfig(ConfigSection(),_L("URI"),uri); + GetStringFromConfig(ConfigSection(),_L("ContentMimeType"),expectedMimeType); + GetBoolFromConfig(ConfigSection(),_L("Known"),mimeTypeKnown); + + // convert to Des8 + HBufC8 *expected = ConvertDes16toHBufC8LC(expectedMimeType); + + // Create CContent and CData + INFO_PRINTF1(_L("Creating data object from content")); + CContent* content = CContent::NewLC(uri); + CData* data = content->OpenContentL(EPeek); + CleanupStack::PushL(data); + + // Get mime type from CData + INFO_PRINTF1(_L("Checking mime type")); + HBufC8 *buffer = HBufC8::NewLC(KCafTestMaxDataTypeLength); + TPtr8 ptr = buffer->Des(); + TBool r = data->GetMimeTypeL(ptr); + + // check if result matches expected result + if(r == mimeTypeKnown && *buffer == *expected) + { + SetTestStepResult(EPass); + } + + CleanupStack::PopAndDestroy(4,expected); + __UHEAP_MARKEND; + return TestStepResult(); + } + + /* + * This step tests file sharing modes + * + */ + +CCAFShareModeStep::~CCAFShareModeStep() + { + } + +CCAFShareModeStep::CCAFShareModeStep(CCAFServer& aParent) : iParent(aParent) + { + SetTestStepName(KCAFShareModeStep); + } + + +TVerdict CCAFShareModeStep::doTestStepL() + { + TVerdict verdict = EFail; + TRAPD(err, verdict = doShareModeStepL()); + if(err != KErrNone) + { + if(err != KErrInUse) + { + User::Leave(err); + } + else + { + User::Leave(KErrGeneral); + } + } + return verdict; + } + +TVerdict CCAFShareModeStep::doShareModeStepL() + { + CAttribute *attr = NULL; + RFile file; + RFs fs; + TPtrC fileName; + TInt err = 0; + + SetTestStepResult(EPass); + + GetStringFromConfig(ConfigSection(),_L("FileName"),fileName); + + // This function works if I step through everything but fails + // when run or step over the TRAP +// User::Leave(KErrGeneral); + + + __UHEAP_MARK; + + INFO_PRINTF2(_L("Creating Content object for file: %S"), &fileName); + CContent* content= CContent::NewL(fileName); + CData *data = NULL; + + fs.Connect(); + CleanupClosePushL(fs); + + + INFO_PRINTF1(_L("Testing EContentShareReadOnly")); + User::LeaveIfError(file.Open(fs, fileName, EFileShareReadersOnly | EFileRead | EFileStream)); + CleanupClosePushL(file); + data = content->OpenContentL(EPeek); + delete data; + data = NULL; + data = content->OpenContentL(EPeek, EContentShareReadOnly); + delete data; + data = NULL; + TRAP(err, data = content->OpenContentL(EPeek, EContentShareReadWrite)); + delete data; + data = NULL; + + // We can open read-write because CAF never writes. + + if(err != KErrNone) + { + SetTestStepResult(EFail); + } + + // However, exclusive mode should be impossible. + + TRAP(err, data = content->OpenContentL(EPeek, EContentShareExclusive)); + delete data; + data = NULL; + if(err != KErrInUse) + { + SetTestStepResult(EFail); + } + CleanupStack::PopAndDestroy(&file); + delete content; + + + INFO_PRINTF1(_L("Testing EContentShareReadWrite")); + content = CContent::NewL(fileName, EContentShareReadWrite); + User::LeaveIfError(file.Open(fs, fileName, EFileShareReadersOrWriters | EFileRead | EFileStream)); + CleanupClosePushL(file); + data = content->OpenContentL(EPeek, EContentShareReadWrite); + delete data; + data = NULL; + + // We should be able to open read-only + + TRAP(err, data = content->OpenContentL(EPeek, EContentShareReadOnly)); + delete data; + data = NULL; + if(err != KErrNone) + { + SetTestStepResult(EFail); + } + + // but not share exclusive + + TRAP(err, data = content->OpenContentL(EPeek, EContentShareExclusive)); + delete data; + data = NULL; + if(err != KErrInUse) + { + SetTestStepResult(EFail); + } + CleanupStack::PopAndDestroy(&file); + + + // Reopen the file with write attributes, and make sure ReadOnly becomes impossible + User::LeaveIfError(file.Open(fs, fileName, EFileShareReadersOrWriters | EFileRead | EFileWrite | EFileStream)); + CleanupClosePushL(file); + + TRAP(err, data = content->OpenContentL(EPeek, EContentShareReadOnly)); + delete data; + data = NULL; + if(err != KErrInUse) + { + SetTestStepResult(EFail); + } + + CleanupStack::PopAndDestroy(&file); + delete content; + + + INFO_PRINTF1(_L("Testing EContentShareExclusive")); + User::LeaveIfError(file.Open(fs, fileName, EFileShareExclusive | EFileRead | EFileStream)); + CleanupClosePushL(file); + TRAP(err, data = CData::NewL(TVirtualPathPtr(fileName), EPeek, EContentShareReadOnly)); + delete data; + data = NULL; + if(err != KErrInUse) + { + SetTestStepResult(EFail); + } + TRAP(err, data = CData::NewL(TVirtualPathPtr(fileName), EPeek, EContentShareReadWrite)); + delete data; + data = NULL; + if(err != KErrInUse) + { + SetTestStepResult(EFail); + } + TRAP(err, data = CData::NewL(TVirtualPathPtr(fileName), EPeek, EContentShareExclusive)); + delete data; + data = NULL; + if(err != KErrInUse) + { + SetTestStepResult(EFail); + } + CleanupStack::PopAndDestroy(&file); + + INFO_PRINTF1(_L("Testing CContent::NewAttributeL")); + content = CContent::NewL(fileName, EContentShareReadWrite); + User::LeaveIfError(file.Open(fs, fileName, EFileShareAny | EFileRead | EFileStream)); + CleanupClosePushL(file); + attr = content->NewAttributeL(ETrue,EContentShareReadWrite); + delete attr; + attr = NULL; + TRAP(err, attr = content->NewAttributeL(ETrue)); + delete attr; + attr = NULL; + if(err != KErrInUse) + { + SetTestStepResult(EFail); + } + CleanupStack::PopAndDestroy(2, &fs); // fs, file + delete content; + + __UHEAP_MARKEND; + return TestStepResult(); + } + +CCAFHandleSizeStep::CCAFHandleSizeStep(CCAFServer& aParent) +:iParent(aParent) +{ + SetTestStepName(KCAFHandleSizeStep); +} + +CCAFHandleSizeStep::~CCAFHandleSizeStep() +{ + + +} + +TVerdict CCAFHandleSizeStep::doTestStepL() + { + __UHEAP_MARK; + + SetTestStepResult(EInconclusive); + + INFO_PRINTF1(_L("Basic Open Content Test")); + + TPtrC uri1; + TPtrC uri2; + GetStringFromConfig(ConfigSection(),_L("URI1"),uri1); + GetStringFromConfig(ConfigSection(),_L("URI2"),uri2); + + INFO_PRINTF2(_L("Creating content object with uri: %S"), &uri1); + + RFile file1; + User::LeaveIfError(file1.Open(iParent.Fs(), uri1, EFileRead)); + CleanupClosePushL(file1); + + CContent* content = CContent::NewLC(file1); + + INFO_PRINTF1(_L("Creating data object from content")); + + CData* data = content->OpenContentL(EPeek); + CleanupStack::PushL(data); + + TInt size = 0; + data->DataSizeL(size); + INFO_PRINTF2(_L("Size of content from caf: %d"),size); + CleanupStack::PopAndDestroy(data); + CleanupStack::PopAndDestroy(content); + + TInt pos = 0; + file1.Seek(ESeekStart, pos); + + INFO_PRINTF2(_L("Creating CData object with uri: %S"), &uri1); + TInt size1 = 0; + data = CData::NewL(file1, KDefaultContentObject(), EPeek); + CleanupStack::PushL(data); + data->DataSizeL(size1); + INFO_PRINTF2(_L("Size of content from caf CData::NewL(): %d"),size1); + CleanupStack::PopAndDestroy(data); + CleanupStack::PopAndDestroy(&file1); + + INFO_PRINTF2(_L("Opening standard RFile interface with uri: %S"),&uri2); + RFile file2; + User::LeaveIfError(file2.Open(iParent.Fs(), uri2, EFileRead)); + + TInt size2; + file2.Size(size2); + file2.Close(); + + INFO_PRINTF2(_L("Size of content from f32: %d"),size2); + + if(size == size2 && size1 == size2) + { + SetTestStepResult(EPass); + } + else + { + SetTestStepResult(EFail); + } + + __UHEAP_MARKEND; + return TestStepResult(); + } + + +CCAFHandleSeekReadStep::~CCAFHandleSeekReadStep() +{ + +} + +CCAFHandleSeekReadStep::CCAFHandleSeekReadStep(CCAFServer& aParent) +: iParent(aParent) + { + SetTestStepName(KCAFHandleSeekReadStep); + } + +TVerdict CCAFHandleSeekReadStep::doTestStepL() + { + SetTestStepResult(EInconclusive); + + TBuf8<2> buf1; + TBuf8<2> buf2; + TRequestStatus status; + + __UHEAP_MARK; + INFO_PRINTF1(_L("Basic Open Content Test")); + + TPtrC uri1; + TPtrC uri2; + GetStringFromConfig(ConfigSection(),_L("URI1"),uri1); + GetStringFromConfig(ConfigSection(),_L("URI2"),uri2); + + INFO_PRINTF2(_L("Creating content object with uri: %S"), &uri1); + RFile file1; + User::LeaveIfError(file1.Open(iParent.Fs(), uri1, EFileRead | EFileShareReadersOnly)); + CleanupClosePushL(file1); + CContent* content = CContent::NewLC(file1); + + INFO_PRINTF1(_L("Creating data object from content")); + CData* data = content->OpenContentL(EPeek); + CleanupStack::PushL(data); + + // Now, open the same file using RFile + RFile file2; + INFO_PRINTF2(_L("Opening standard RFile interface with uri: %S"),&uri2); + //User::LeaveIfError(file2.Open(iParent.Fs(), uri2, EFileRead | EFileShareReadersOnly)); + TInt res = file2.Open(iParent.Fs(), uri2, EFileRead | EFileShareReadersOnly); + CleanupClosePushL(file2); + + TInt size = 0; + file2.Size(size); + INFO_PRINTF2(_L("Size of content from f32: %d"),size); + + // Seek and read from start using both CAF and RFile + TInt pos1 = size/4; + data->Seek(ESeekStart, pos1); + TInt pos2 = size/4; + file2.Seek(ESeekStart, pos2); + data->Read(buf1); + file2.Read(buf2); + INFO_PRINTF2(_L("Position from ESeekStart test using CData: %d"), pos1); + INFO_PRINTF2(_L("Position from ESeekStart test using RFile: %d"), pos2); + if (buf1 != buf2 || pos1 != pos2 || pos1 != size/4) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // set the location within the file then retrieve the current location within the file + pos1=0; + pos2=0; + data->Seek(ESeekCurrent, pos1); + file2.Seek(ESeekCurrent, pos2); + + INFO_PRINTF2(_L("Current position using CData: %d"), pos1); + INFO_PRINTF2(_L("Current position using RFile: %d"), pos2); + + if(pos1 != pos2 || pos1 != (size/4 + buf1.Length())) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // Seek and read from current using both CAF and RFile + pos1 = size/4; + data->Seek(ESeekCurrent, pos1); + pos2 = size/4; + file2.Seek(ESeekCurrent, pos2); + data->Read(buf1); + file2.Read(buf2); + INFO_PRINTF2(_L("Position from ESeekCurrent test using CData: %d"), pos1); + INFO_PRINTF2(_L("Position from ESeekCurrent test using RFile: %d"), pos2); + if (buf1 != buf2 || pos1 != pos2 || pos1 != (size/2 + buf1.Length())) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // Seek and read from end using both CAF and RFile + pos1 = -size/4; + data->Seek(ESeekEnd, pos1); + pos2 = -size/4; + file2.Seek(ESeekEnd, pos2); + data->Read(buf1); + file2.Read(buf2); + INFO_PRINTF2(_L("Position from ESeekEnd test using CData: %d"), pos1); + INFO_PRINTF2(_L("Position from ESeekEnd test using RFile: %d"), pos2); + if (buf1 != buf2 || pos1 != pos2 || pos1 != (size - size/4)) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // Test other overloaded forms of CData::Read + + // Read only 1 byte using both CAF and RFile + pos1 = size/4; + data->Seek(ESeekStart, pos1); + pos2 = size/4; + file2.Seek(ESeekStart, pos2); + data->Read(buf1,1); + file2.Read(buf2,1); + INFO_PRINTF2(_L("Data Length from CData::Read(TDesC& ,TInt Length) : %d"), buf1.Length()); + INFO_PRINTF2(_L("Data Length from RFile::Read(TDesC& , TInt Length): %d"), buf2.Length()); + + pos1=0; + pos2=0; + data->Seek(ESeekCurrent, pos1); + file2.Seek(ESeekCurrent,pos2); + if (buf1 != buf2 || pos1 != pos2 || buf1.Length() != buf2.Length()) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // Read asynchronously using both CAF and RFile + INFO_PRINTF1(_L("Asynchronous read from CAF and RFile")); + pos1 = size/4; + data->Seek(ESeekStart, pos1); + pos2 = size/4; + file2.Seek(ESeekStart, pos2); + status = KRequestPending; + data->Read(buf1,status); + User::WaitForRequest(status); + status = KRequestPending; + file2.Read(buf2,status); + User::WaitForRequest(status); + INFO_PRINTF2(_L("Data length from CData::Read(TDesC& ,TRequestStatus& aStatus): %d"), buf1.Length()); + INFO_PRINTF2(_L("Data length from RFile::Read(TDesC& , TRequestStatus& aStatus): %d"), buf2.Length()); + + pos1=0; + pos2=0; + data->Seek(ESeekCurrent, pos1); + file2.Seek(ESeekCurrent,pos2); + if (buf1 != buf2 || pos1 != pos2 || buf1.Length() != buf2.Length()) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // Read only 1 byte asynchronously using both CAF and RFile + INFO_PRINTF1(_L("Asynchronous read of 1 byte from CAF and RFile")); + pos1 = size/4; + data->Seek(ESeekStart, pos1); + pos2 = size/4; + file2.Seek(ESeekStart, pos2); + status = KRequestPending; + data->Read(buf1,1,status); + User::WaitForRequest(status); + status = KRequestPending; + file2.Read(buf2,1, status); + User::WaitForRequest(status); + INFO_PRINTF2(_L("Data Length from CData::Read(TDesC& ,TInt Length, TRequestStatus aStatus) : %d"), buf1.Length()); + INFO_PRINTF2(_L("Data Length from RFile::Read(TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf2.Length()); + + pos1=0; + pos2=0; + data->Seek(ESeekCurrent, pos1); + file2.Seek(ESeekCurrent,pos2); + if (buf1 != buf2 || pos1 != pos2 || buf1.Length() != buf2.Length()) + { + INFO_PRINTF1(_L("ERROR buffers or position do not match")); + SetTestStepResult(EFail); + } + + // read past EOF + pos1 = size+1; + pos2 = size+1; + data->Seek(ESeekStart, pos1); + file2.Seek(ESeekStart, pos2); + data->Read(buf1); + file2.Read(buf2); + + if(buf1.Length() != 0 || buf1.Length() != 0) + { + INFO_PRINTF1(_L("ERROR data read past EOF")); + SetTestStepResult(EFail); + } + + CleanupStack::PopAndDestroy(4); + + __UHEAP_MARKEND; + + if (TestStepResult() != EFail) + { + SetTestStepResult(EPass); + } + + return TestStepResult(); + } + +/* + * Step reads from a CData from multiple threads using RFile handle + * + */ + +CCAFHandleMultiThreadCDataStep::~CCAFHandleMultiThreadCDataStep() + { + + } + + CCAFHandleMultiThreadCDataStep::CCAFHandleMultiThreadCDataStep(CCAFServer& aParent) + :iParent(aParent) + { + + SetTestStepName(KCAFHandleMultiThreadCDataStep); + } + +TVerdict CCAFHandleMultiThreadCDataStep::doTestStepL() + { + TBuf8<2> buf; + + __UHEAP_MARK; + _LIT(KCDataThread,"CData_Thread"); + + SetTestStepResult(EInconclusive); + + INFO_PRINTF1(_L("Multi Thread CData Test using RFile Handle")); + + TPtrC uri; + GetStringFromConfig(ConfigSection(),_L("URI"),uri); + + INFO_PRINTF1(_L("Creating data object from content")); + RFile file; + User::LeaveIfError(file.Open(iParent.Fs(), uri, EFileRead)); + + CleanupClosePushL(file); + + CContent* content = CContent::NewLC(file); + CData* data = content->OpenContentL(EPeek); + CleanupStack::PushL(data); + + TInt size, pos; + + // Create a mutex for communication between our thread and the new thread + RSemaphore threadSemaphore; + threadSemaphore.CreateGlobal(KCDataThreadSemaphore(), 1, EOwnerProcess); + threadSemaphore.Wait(); + + // fire up a new thread, stack size and heap size 8k, might need to be bigger in the future + RThread readerThread; + User::LeaveIfError(readerThread.Create(KCDataThread(),CCAFMultiThreadCDataStep::ReaderThreadEntry,8192, KMinHeapSize, 8192, (TAny *) data, EOwnerProcess)); + + // request notification of thread completion + TRequestStatus stat; + readerThread.Logon(stat); + readerThread.Resume(); + + + data->DataSizeL(size); + pos = size/2; + data->Seek(ESeekStart,pos); + data->Read(buf); + + threadSemaphore.Wait(); // wait for thread function to run and signal the semaphore + threadSemaphore.Signal(); // finished with semaphore + threadSemaphore.Close(); // so close + + User::WaitForRequest(stat); // wait for thread to finish + TInt error=(readerThread.ExitType()==EExitPanic) ? KErrGeneral : stat.Int(); + User::LeaveIfError(error); + readerThread.Close(); // close the thread + + CleanupStack::PopAndDestroy(data); + CleanupStack::PopAndDestroy(content); + CleanupStack::PopAndDestroy(&file); //file + + + __UHEAP_MARKEND; + + SetTestStepResult(EPass); + return TestStepResult(); +} + +TInt CCAFHandleMultiThreadCDataStep::ReaderThreadEntry(TAny *aPtr) + { + TBuf8 <2> buf; + CData *data = reinterpret_cast (aPtr); + + // create a trap handler + CTrapCleanup* cleanup = CTrapCleanup::New(); + + RSemaphore threadSemaphore; + threadSemaphore.OpenGlobal(KCDataThreadSemaphore() ,EOwnerProcess); + + data->Read(buf); + threadSemaphore.Signal(); // allow original thread to continue + threadSemaphore.Close(); + + delete cleanup; + return KErrNone; + } + +/* + * Data attribute step + * + */ + +CCAFDataAttributeStep::~CCAFDataAttributeStep() + { + } + +CCAFDataAttributeStep::CCAFDataAttributeStep(CCAFServer& aParent) : iParent(aParent) + { + SetTestStepName(KCAFDataAttributeStep); + } + +TVerdict CCAFDataAttributeStep::doTestStepL() + { +#ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT + TBool wmdrmFlag = EFalse; + GetBoolFromConfig(ConfigSection(),_L("wmdrmEnabled"), wmdrmFlag); + + if(wmdrmFlag) + { + TVerdict verdict = doWmdrmTestStepL(); + return verdict; + } +#endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT + + TInt attribute; + TInt value = KErrNone; + TInt expectedValue = KErrNone; + TPtrC uri; + TPtrC uniqueId; + + SetTestStepResult(EPass); + + GetIntFromConfig(ConfigSection(),_L("attribute"),attribute); + GetStringFromConfig(ConfigSection(),_L("uri"),uri); + GetStringFromConfig(ConfigSection(),_L("uniqueid"),uniqueId); + GetIntFromConfig(ConfigSection(),_L("value"),expectedValue); + + __UHEAP_MARK; + CContent *content = CContent::NewLC(uri); + CData *data = content->OpenContentL(EPeek, uniqueId); + User::LeaveIfError(data->GetAttribute(attribute, value)); + delete data; + if(expectedValue != value) + { + SetTestStepResult(EFail); + INFO_PRINTF3(_L("CData::GetAttribute() Expected value: %d, actual value: %d"), expectedValue, value); + } + + CleanupStack::PopAndDestroy(content); + __UHEAP_MARKEND; + return TestStepResult(); + } + +/* + * Data attributeset step + * + */ + +CCAFDataAttributeSetStep::~CCAFDataAttributeSetStep() + { + } + +CCAFDataAttributeSetStep::CCAFDataAttributeSetStep(CCAFServer& aParent) : iParent(aParent) + { + SetTestStepName(KCAFDataAttributeSetStep); + } + +TVerdict CCAFDataAttributeSetStep::doTestStepL() + { +#ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT + TBool wmdrmFlag = EFalse; + GetBoolFromConfig(ConfigSection(),_L("wmdrmEnabled"), wmdrmFlag); + + if(wmdrmFlag) + { + TVerdict verdict = doWmdrmTestStepL(); + return verdict; + } +#endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT + + TInt expectedValue1; + TInt expectedValue2; + TInt value1; + TInt value2; + TInt attribute1; + TInt attribute2; + TInt result = KErrNone; + TPtrC uri; + TPtrC uniqueId; + + SetTestStepResult(EPass); + + GetStringFromConfig(ConfigSection(),_L("uri"),uri); + GetStringFromConfig(ConfigSection(),_L("uniqueid"),uniqueId); + GetIntFromConfig(ConfigSection(),_L("attribute1"),attribute1); + GetIntFromConfig(ConfigSection(),_L("attribute2"),attribute2); + GetIntFromConfig(ConfigSection(),_L("value1"),expectedValue1); + GetIntFromConfig(ConfigSection(),_L("value2"),expectedValue2); + + __UHEAP_MARK; + CContent *content = CContent::NewLC(uri); + RAttributeSet attributeSet; + CleanupClosePushL(attributeSet); + attributeSet.AddL(attribute1); + attributeSet.AddL(attribute2); + + CData *data = content->OpenContentL(EPeek, uniqueId); + result = data->GetAttributeSet(attributeSet); + delete data; + if(result != KErrNone) + { + SetTestStepResult(EFail); + INFO_PRINTF1(_L("CData::GetAttribute() failed")); + } + User::LeaveIfError(attributeSet.GetValue(attribute1, value1)); + User::LeaveIfError(attributeSet.GetValue(attribute2, value2)); + if(value1 != expectedValue1 || value2 != expectedValue2 || attributeSet.Count() != 2) + { + SetTestStepResult(EFail); + INFO_PRINTF1(_L("CData::GetAttributeSet() values don't match expected values")); + } + CleanupStack::PopAndDestroy(&attributeSet); + CleanupStack::PopAndDestroy(content); + + __UHEAP_MARKEND; + return TestStepResult(); + } + + +/* + * Data string attribute step + * + */ + +CCAFDataStringAttributeStep::~CCAFDataStringAttributeStep() + { + } + +CCAFDataStringAttributeStep::CCAFDataStringAttributeStep(CCAFServer& aParent) : iParent(aParent) + { + SetTestStepName(KCAFDataStringAttributeStep); + } + +TVerdict CCAFDataStringAttributeStep::doTestStepL() + { +#ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT + TBool wmdrmFlag = EFalse; + GetBoolFromConfig(ConfigSection(),_L("wmdrmEnabled"), wmdrmFlag); + + if(wmdrmFlag) + { + TVerdict verdict = doWmdrmTestStepL(); + return verdict; + } +#endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT + + TInt expectedResult; + TInt attribute; + TPtrC expectedValue; + TBuf <200> value; + TInt result = KErrNone; + TPtrC uri; + TPtrC uniqueId; + + SetTestStepResult(EPass); + + GetIntFromConfig(ConfigSection(),_L("attribute"),attribute); + GetStringFromConfig(ConfigSection(),_L("uri"),uri); + GetStringFromConfig(ConfigSection(),_L("uniqueid"),uniqueId); + GetStringFromConfig(ConfigSection(),_L("value"),expectedValue); + GetIntFromConfig(ConfigSection(),_L("result"),expectedResult); + + __UHEAP_MARK; + CContent *content = CContent::NewLC(uri); + CData *data = content->OpenContentL(EPeek, uniqueId); + result = data->GetStringAttribute(attribute, value); + delete data; + if(result != expectedResult) + { + SetTestStepResult(EFail); + INFO_PRINTF3(_L("CData::GetStringAttribute() Expected result: %d, actual result: %d"), expectedResult, result); + } + if(value != expectedValue) + { + SetTestStepResult(EFail); + INFO_PRINTF3(_L("CData::GetStringAttribute() Expected value: %S, actual result: %S"), &expectedValue, &value); + } + + CleanupStack::PopAndDestroy(content); + + __UHEAP_MARKEND; + return TestStepResult(); + } + +/* + * Data StringAttributeSet step + * + */ + +CCAFDataStringAttributeSetStep::~CCAFDataStringAttributeSetStep() + { + } + +CCAFDataStringAttributeSetStep::CCAFDataStringAttributeSetStep(CCAFServer& aParent) : iParent(aParent) + { + SetTestStepName(KCAFDataStringAttributeSetStep); + } + +TVerdict CCAFDataStringAttributeSetStep::doTestStepL() + { +#ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT + TBool wmdrmFlag = EFalse; + GetBoolFromConfig(ConfigSection(),_L("wmdrmEnabled"), wmdrmFlag); + + if(wmdrmFlag) + { + TVerdict verdict = doWmdrmTestStepL(); + return verdict; + } +#endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT + + TPtrC expectedValue1; + TPtrC expectedValue2; + TBuf <200> value1; + TBuf <200> value2; + TInt attribute1; + TInt attribute2; + TInt result = KErrNone; + TInt result1; + TInt result2; + TPtrC uri; + TPtrC uniqueId; + + SetTestStepResult(EPass); + + GetStringFromConfig(ConfigSection(),_L("uri"),uri); + GetStringFromConfig(ConfigSection(),_L("uniqueid"),uniqueId); + GetIntFromConfig(ConfigSection(),_L("attribute1"),attribute1); + GetIntFromConfig(ConfigSection(),_L("attribute2"),attribute2); + GetStringFromConfig(ConfigSection(),_L("value1"),expectedValue1); + GetStringFromConfig(ConfigSection(),_L("value2"),expectedValue2); + GetIntFromConfig(ConfigSection(),_L("result1"),result1); + GetIntFromConfig(ConfigSection(),_L("result2"),result2); + + __UHEAP_MARK; + CContent *content = CContent::NewLC(uri); + RStringAttributeSet attributeSet; + CleanupClosePushL(attributeSet); + attributeSet.AddL(attribute1); + attributeSet.AddL(attribute2); + + CData *data = content->OpenContentL(EPeek, uniqueId); + result = data->GetStringAttributeSet(attributeSet); + delete data; + if(result != KErrNone) + { + SetTestStepResult(EFail); + INFO_PRINTF1(_L("CData::GetAttribute() failed")); + } + if(result1 != attributeSet.GetValue(attribute1, value1)) + { + INFO_PRINTF1(_L("RStringAttributeSet::GetValue failed")); + } + if(result2 != attributeSet.GetValue(attribute2, value2)) + { + INFO_PRINTF1(_L("RStringAttributeSet::GetValue failed")); + } + if( value1 != expectedValue1 || value2 != expectedValue2 || attributeSet.Count() != 2) + { + SetTestStepResult(EFail); + INFO_PRINTF1(_L("CData::GetAttributeSet() values don't match expected values")); + } + CleanupStack::PopAndDestroy(&attributeSet); + CleanupStack::PopAndDestroy(content); + + + __UHEAP_MARKEND; + return TestStepResult(); + } + + +CCAFExecuteIntentStep::~CCAFExecuteIntentStep() + { + } + +CCAFExecuteIntentStep::CCAFExecuteIntentStep(CCAFServer& aParent) +: iParent(aParent) + { + SetTestStepName(KCAFSizeStep); + } + +TVerdict CCAFExecuteIntentStep::doTestStepL() + { + __UHEAP_MARK; + + SetTestStepResult(EInconclusive); + + INFO_PRINTF1(_L("Execute Intent Test")); + + TPtrC fileName; + TPtrC uniqueId; + TInt intent = EPeek; + TInt expectedResult = KErrNone; + + GetStringFromConfig(ConfigSection(),_L("FileName"),fileName); + GetStringFromConfig(ConfigSection(),_L("UniqueId"),uniqueId); + GetIntFromConfig(ConfigSection(),_L("Intent"),intent); + GetIntFromConfig(ConfigSection(),_L("ExpectedResult"),expectedResult); + + INFO_PRINTF3(_L("Creating CData object with filename: %S, UniqueId: %S"), &fileName, &uniqueId); + + CData* data = NULL; + + TRAPD(err, data = CData::NewL(TVirtualPathPtr(fileName, uniqueId),static_cast(intent), EContentShareReadOnly)); + + if(err != expectedResult) + { + INFO_PRINTF2(_L("Unexpected result, EvaluateIntent() returned %d"), err); + } + else + { + SetTestStepResult(EPass); + if(err == KErrNone) + { + err = data->ExecuteIntent(static_cast(intent)); + if(err == KErrNone) + { + TBuf8 <128> buffer; + TInt length = 128; + + // read the entire content object + while(err == KErrNone && length > 0) + { + err = data->Read(buffer); + length = buffer.Length(); + } + if(err != KErrEof && err != KErrNone) + { + INFO_PRINTF2(_L("Unexpected error while reading content object: %d"), err); + SetTestStepResult(EFail); + } + } + else + { + INFO_PRINTF2(_L("Unexpected error, EvaluteIntent succeeded but ExecuteIntent failed with error: %d"), err); + SetTestStepResult(EFail); + } + } + } + + delete data; + + __UHEAP_MARKEND; + return TestStepResult(); + } + +/* + * DRM File Open Performance Test Step + * + */ + +CCAFDRMFileOpenPerformanceTest::~CCAFDRMFileOpenPerformanceTest() + { + iIterationSum = 0; + } + +CCAFDRMFileOpenPerformanceTest::CCAFDRMFileOpenPerformanceTest(CCAFServer& aParent) : iParent(aParent) + { + SetTestStepName(KCAFDRMFileOpenPerformanceStep); + } + +TVerdict CCAFDRMFileOpenPerformanceTest::doTestStepL() + { + __UHEAP_MARK; + + INFO_PRINTF1(_L("DRM File Open Performance Test")); + + TPtrC inputFileName; + TInt maxValue = 0 ,iterCount = 0; + + GetStringFromConfig(ConfigSection(),_L("FileName"),inputFileName); + GetIntFromConfig(ConfigSection(),_L("IterationCount"),iterCount); + GetIntFromConfig(ConfigSection(),_L("MaxTimeLimitInMS"),maxValue); + + iIterationSum=0; + // iterated iterCount times to get the average time taken to open the file. + for (TInt i = 0; i < iterCount; ++i) + { + OpenAndReadFileContentL(inputFileName); + } + + TInt tickPeriod; + HAL::Get(HAL::ENanoTickPeriod, tickPeriod); + TInt nTickPeriodMS = tickPeriod / KCafTestSecToMS; + + TInt avgTimeForFileOpen = (iIterationSum * nTickPeriodMS) / iterCount; + if((avgTimeForFileOpen > maxValue)) + { + INFO_PRINTF1(_L("Performance Test failed.")); + SetTestStepResult(EFail); + } + + INFO_PRINTF2(_L("Expected maximum time to open DRM file in millisecs is : %d"), maxValue); + INFO_PRINTF2(_L("Obtained time in millisecs is: %d"), avgTimeForFileOpen); + + __UHEAP_MARKEND; + + return TestStepResult(); + } + +void CCAFDRMFileOpenPerformanceTest::OpenAndReadFileContentL(const TDesC& aFileName) + { + TPtrC uniqueIdentifier; + + GetStringFromConfig(ConfigSection(),_L("UniqueId"),uniqueIdentifier); + CContent *content = CContent::NewLC(aFileName); + CData *data = NULL; + TUint32 tickCounterValBeforeFileOpen, tickCounterValAfterFileOpen; + if(uniqueIdentifier.Length() > 0) + { + tickCounterValBeforeFileOpen = User::NTickCount(); + data = content->OpenContentL(EPeek,uniqueIdentifier); + tickCounterValAfterFileOpen = User::NTickCount(); + } + else + { + tickCounterValBeforeFileOpen = User::NTickCount(); + data = content->OpenContentL(EPeek); + tickCounterValAfterFileOpen = User::NTickCount(); + } + delete data; + // finished with Data object + CleanupStack::PopAndDestroy(content); + iIterationSum += tickCounterValAfterFileOpen - tickCounterValBeforeFileOpen; + } + +#ifdef SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT + +CWmdrmCAFContentStep::~CWmdrmCAFContentStep() + { + } + +CWmdrmCAFContentStep::CWmdrmCAFContentStep() + { + SetTestStepName(KWmdrmCAFContentStep); + } + + +TVerdict CWmdrmCAFContentStep::doTestStepL() + { + SetTestStepResult(EFail); + + TBool protectedVal; + GetBoolFromConfig(ConfigSection(),_L("attribValue1"), protectedVal); + TBool forwardable; + GetBoolFromConfig(ConfigSection(),_L("attribValue2"), forwardable); + + TBool headerDataPresent = ETrue; + GetBoolFromConfig(ConfigSection(),_L("headerDataFlag"), headerDataPresent); + + INFO_PRINTF1(_L("Verify CContent APIs for WMDRM content")); + + __UHEAP_MARK; + + CContent* content = NULL; + + // this condition verifies that CContent construction leaves with KErrMissingWmdrmHeaderData, + // when no header data is provided. + if(!headerDataPresent) + { + content = CContent::NewL(KNullDesC8()); + return EPass; + } + + // create a dummy header data. + HBufC8* headerData = CreateWmdrmHeaderLC(); + + // Open a file and retrieve the attributes. + // If headerDataPresent is false, the code will never reach here.s + content = CContent::NewL(*headerData); + CleanupStack::PushL(content); + CAttribute* attrs = content->NewAttributeL(ETrue); + CleanupStack::PushL(attrs); + + TBool value1 = attrs->ResponseSet().IsSet(EIsProtected); + TBool value2 = attrs->ResponseSet().IsSet(EIsForwardable); + if(value1 == protectedVal && value2 == forwardable) + { + SetTestStepResult(EPass); + } + + CleanupStack::PopAndDestroy(3, headerData); + + __UHEAP_MARKEND; + return TestStepResult(); + } + + +CWmdrmCAFDataStep::~CWmdrmCAFDataStep() + { + } + +CWmdrmCAFDataStep::CWmdrmCAFDataStep() + { + SetTestStepName(KWmdrmCAFDataStep); + } + +TVerdict CWmdrmCAFDataStep::doTestStepL() + { + SetTestStepResult(EFail); + + TInt attribute; + TInt expectedValue = KErrNone; + + GetIntFromConfig(ConfigSection(),_L("attribute"), attribute); + GetIntFromConfig(ConfigSection(),_L("value"), expectedValue); + +__UHEAP_MARK; + + HBufC8* headerData = CreateWmdrmHeaderLC(); + + CContent *content = CContent::NewLC(*headerData); + CData *data = content->OpenContentL(EPeek); + TInt value = KErrNone; + User::LeaveIfError(data->GetAttribute(attribute, value)); + delete data; + + if(expectedValue == value) + { + SetTestStepResult(EPass); + } + else + { + INFO_PRINTF3(_L("CData::GetAttribute() Expected value: %d, actual value: %d"), expectedValue, value); + } + + CleanupStack::PopAndDestroy(2, headerData); +__UHEAP_MARKEND; + + return TestStepResult(); + } + + +CWmdrmCAFReadStep::~CWmdrmCAFReadStep() + { + } + +CWmdrmCAFReadStep::CWmdrmCAFReadStep() + { + SetTestStepName(KWmdrmCAFReadStep); + } + + +TVerdict CWmdrmCAFReadStep::doTestStepL() + { + SetTestStepResult(EFail); + + TBool synchronous = EFalse; + GetBoolFromConfig(ConfigSection(),_L("synchronous"), synchronous); + TBool intent = EFalse; + GetBoolFromConfig(ConfigSection(),_L("intent"), intent); + TPtrC inputPacket; + GetStringFromConfig(ConfigSection(),_L("inputPacket"), inputPacket); + TPtrC expectedOutput; + GetStringFromConfig(ConfigSection(),_L("outputPacket"), expectedOutput); + +__UHEAP_MARK; + TPtrC header; + HBufC8* headerData = NULL; + + if(GetStringFromConfig(ConfigSection(),_L("header"), header)) + { + headerData = ConvertDes16toHBufC8LC(header); + } + else + { + headerData = CreateWmdrmHeaderLC(); + } + + TInt result = 0; + if(!synchronous) + { + result = TestAsynchronousReadL(*headerData, intent, inputPacket, expectedOutput); + } + else + { + result = TestSynchronousReadL(*headerData, intent, inputPacket, expectedOutput); + } + + if(result == KErrNone) + { + SetTestStepResult(EPass); + } + + CleanupStack::PopAndDestroy(headerData); +__UHEAP_MARKEND; + + return TestStepResult(); + } + +TInt CWmdrmCAFReadStep::TestSynchronousReadL(const TDesC8& aHeaderData, TBool aIntent, TDesC& aInputPacket, TDesC& aExpectedOutput) + { +__UHEAP_MARK; + CData* data = NULL; + TInt returnVal = KErrGeneral; + + if(aIntent) + { + data = CData::NewL(aHeaderData, EPeek); + } + else + { + data = CData::NewL(aHeaderData); + } + + CleanupStack::PushL(data); + + if(aInputPacket.Length() <= 0) + { + // dummy output buffer.This loop essentially tests the error condition KErrInsufficientDataPacketLength. + TBuf8<2> outputBuffer; + User::LeaveIfError(data->Read(KNullDesC8(), outputBuffer)); + } + + else + { + HBufC8* inputPacket = ConvertDes16toHBufC8LC(aInputPacket); + HBufC8* outputPacket = HBufC8::NewLC(aInputPacket.Length()); + TPtr8 outputPacketPtr = outputPacket->Des(); + + User::LeaveIfError(data->Read(*inputPacket, outputPacketPtr)); + HBufC8* expectedOutput = ConvertDes16toHBufC8LC(aExpectedOutput); + if(expectedOutput->Compare(*outputPacket) == KErrNone) + { + returnVal = KErrNone; + } + + CleanupStack::PopAndDestroy(3, inputPacket); + } + + CleanupStack::PopAndDestroy(data); +__UHEAP_MARKEND; + + return returnVal; + } + +TInt CWmdrmCAFReadStep::TestAsynchronousReadL(const TDesC8& aHeaderData, TBool aIntent, TDesC& aInputPacket, TDesC& aExpectedOutput) + { +__UHEAP_MARK; + CData* data = NULL; + TInt returnVal = KErrGeneral; + + if(aIntent) + { + data = CData::NewL(aHeaderData, EPeek); + } + else + { + data = CData::NewL(aHeaderData); + } + + CleanupStack::PushL(data); + + if(aInputPacket.Length() <= 0) + { + TBuf8<2> outputBuffer; + User::LeaveIfError(data->Read(KNullDesC8(), outputBuffer)); + } + + else + { + HBufC8* inputPacket = ConvertDes16toHBufC8LC(aInputPacket); + HBufC8* outputPacket = HBufC8::NewLC(aInputPacket.Length()); + TPtr8 outputPacketPtr = outputPacket->Des(); + + TRequestStatus status; + data->Read(*inputPacket, outputPacketPtr, status); + User::WaitForRequest(status); + + if(status.Int() != KErrNone) + { + CleanupStack::PopAndDestroy(3, data); + return status.Int(); + } + + HBufC8* expectedOutput = ConvertDes16toHBufC8LC(aExpectedOutput); + if(expectedOutput->Compare(*outputPacket) == KErrNone) + { + returnVal = KErrNone; + } + + CleanupStack::PopAndDestroy(3, inputPacket); + } + + CleanupStack::PopAndDestroy(data); +__UHEAP_MARKEND; + + return returnVal; + } + +TVerdict CCAFDataAttributeStep::doWmdrmTestStepL() + { + SetTestStepResult(EFail); + + TInt attribVal; + GetIntFromConfig(ConfigSection(),_L("attribute"), attribVal); + + TInt expectedValue; + GetIntFromConfig(ConfigSection(),_L("value"), expectedValue); + +__UHEAP_MARK; + TPtrC header; + HBufC8* headerData = NULL; + + if(GetStringFromConfig(ConfigSection(),_L("header"), header)) + { + headerData = ConvertDes16toHBufC8LC(header); + } + else + { + headerData = CreateWmdrmHeaderLC(); + } + + CContent *content = CContent::NewLC(*headerData); + CData *data = content->OpenContentL(EPeek); + TInt value; + User::LeaveIfError(data->GetAttribute(attribVal, value)); + delete data; + + if(expectedValue == value) + { + SetTestStepResult(EPass); + } + else + { + INFO_PRINTF3(_L("CData::GetAttribute() Expected value: %d, actual value: %d"), expectedValue, value); + } + + CleanupStack::PopAndDestroy(2, headerData); +__UHEAP_MARKEND; + + return TestStepResult(); + } + + +TVerdict CCAFDataAttributeSetStep::doWmdrmTestStepL() + { + SetTestStepResult(EFail); + + TInt attribute1; + GetIntFromConfig(ConfigSection(),_L("attribute1"),attribute1); + + TInt attribute2; + GetIntFromConfig(ConfigSection(),_L("attribute2"),attribute2); + + TInt expectedValue1; + GetIntFromConfig(ConfigSection(),_L("value1"),expectedValue1); + + TInt expectedValue2; + GetIntFromConfig(ConfigSection(),_L("value2"),expectedValue2); + +__UHEAP_MARK; + + TPtrC header; + HBufC8* headerData = NULL; + + if(GetStringFromConfig(ConfigSection(),_L("header"), header)) + { + headerData = ConvertDes16toHBufC8LC(header); + } + else + { + headerData = CreateWmdrmHeaderLC(); + } + + CContent *content = CContent::NewLC(*headerData); + CData *data = content->OpenContentL(EPeek); + + RAttributeSet attributeSet; + CleanupClosePushL(attributeSet); + attributeSet.AddL(attribute1); + attributeSet.AddL(attribute2); + + TInt result = data->GetAttributeSet(attributeSet); + delete data; + + if(result == KErrNone) + { + TInt value1; + User::LeaveIfError(attributeSet.GetValue(attribute1, value1)); + + TInt value2; + User::LeaveIfError(attributeSet.GetValue(attribute2, value2)); + + if(expectedValue1 == value1 && expectedValue2 == value2 && attributeSet.Count() == 2) + { + SetTestStepResult(EPass); + } + else + { + INFO_PRINTF1(_L("CData::GetAttributeSet() values don't match expected values")); + } + } + + else + { + INFO_PRINTF1(_L("CData::GetAttributeSet() failed")); + } + + CleanupStack::PopAndDestroy(3, headerData); + +__UHEAP_MARKEND; + + return TestStepResult(); + } + + +TVerdict CCAFDataStringAttributeStep::doWmdrmTestStepL() + { + SetTestStepResult(EFail); + + TInt attribVal; + GetIntFromConfig(ConfigSection(),_L("attribute"),attribVal); + + TPtrC expectedValue; + GetStringFromConfig(ConfigSection(),_L("value"),expectedValue); + + TInt expectedResult; + GetIntFromConfig(ConfigSection(),_L("result"),expectedResult); + +__UHEAP_MARK; + TPtrC header; + HBufC8* headerData = NULL; + + if(GetStringFromConfig(ConfigSection(),_L("header"), header)) + { + headerData = ConvertDes16toHBufC8LC(header); + } + else + { + headerData = CreateWmdrmHeaderLC(); + } + + CContent *content = CContent::NewLC(*headerData); + CData *data = content->OpenContentL(EPeek); + + TBuf <200> value; + TInt result = data->GetStringAttribute(attribVal, value); + delete data; + + if(result == expectedResult && value == expectedValue) + { + SetTestStepResult(EPass); + } + else + { + INFO_PRINTF3(_L("CData::GetStringAttribute() Expected result: %d, actual result: %d"), expectedResult, result); + INFO_PRINTF3(_L("CData::GetStringAttribute() Expected value: %S, actual value: %S"), &expectedValue, &value); + } + + CleanupStack::PopAndDestroy(2, headerData); + +__UHEAP_MARKEND; + + return TestStepResult(); + } + + +TVerdict CCAFDataStringAttributeSetStep::doWmdrmTestStepL() + { + SetTestStepResult(EFail); + + TInt attribute1; + GetIntFromConfig(ConfigSection(),_L("attribute1"),attribute1); + + TInt attribute2; + GetIntFromConfig(ConfigSection(),_L("attribute2"),attribute2); + + TPtrC expectedValue1; + GetStringFromConfig(ConfigSection(),_L("value1"),expectedValue1); + + TPtrC expectedValue2; + GetStringFromConfig(ConfigSection(),_L("value2"),expectedValue2); + +__UHEAP_MARK; + TPtrC header; + HBufC8* headerData = NULL; + + if(GetStringFromConfig(ConfigSection(),_L("header"), header)) + { + headerData = ConvertDes16toHBufC8LC(header); + } + else + { + headerData = CreateWmdrmHeaderLC(); + } + + CContent *content = CContent::NewLC(*headerData); + CData *data = content->OpenContentL(EPeek); + + RStringAttributeSet attributeSet; + CleanupClosePushL(attributeSet); + attributeSet.AddL(attribute1); + attributeSet.AddL(attribute2); + + TInt result = data->GetStringAttributeSet(attributeSet); + delete data; + + TBuf <200> value1; + TBuf <200> value2; + if(result == KErrNone) + { + TInt result3 = attributeSet.GetValue(attribute1, value1); + TInt result4 = attributeSet.GetValue(attribute2, value2); + + if(value1 == expectedValue1 && value2 == expectedValue2 && attributeSet.Count() == 2 + && result3 == KErrNone && result4 == KErrNone) + { + SetTestStepResult(EPass); + } + else + { + INFO_PRINTF3(_L("RStringAttributeSet::GetValue() for attribute1.Expected value: %S, actual value: %S"), &expectedValue1, &value1); + INFO_PRINTF3(_L("RStringAttributeSet::GetValue() for attribute2.Expected value: %S, actual value: %S"), &expectedValue2, &value2); + INFO_PRINTF3(_L("RStringAttributeSet::GetValue() for attribute1. Expected result: %d, actual result: %d"), 0, result3); + INFO_PRINTF3(_L("RStringAttributeSet::GetValue() for attribute2. Expected result: %d, actual result: %d"), 0, result4); + } + } + else + { + INFO_PRINTF1(_L("CData::GetStringAttributeSet() failed")); + } + + CleanupStack::PopAndDestroy(3, headerData); + +__UHEAP_MARKEND; + + return TestStepResult(); + } + +#endif //SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT