/*

* 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 <test/testexecutelog.h>

#include <caf/content.h>

#include <caf/data.h>

#include <caf/attribute.h>

#include "cafserver.h"

#include "bitset.h"

#include "Consumerstep.h"

#include "attributeset.h"

#include "stringattributeset.h"

#include <caf/virtualpath.h>

#include <e32hal.h>

#include <hal.h>

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);