// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <s32file.h>

#include "TEST.H"

#include <s32mem.h>

/* this fixes a MSVC link warning */

#ifdef __VC32__

#pragma comment (linker, "/opt:noref") 

#endif

#undef test  //there is a "TEST" macro which hides "RTest TEST" declaration.

RTest test(_L("Log Event Test Harness"));

TBool CompareEvents(const CLogEvent& aLeft, const CLogEvent& aRight)

	{

	TBool ret = aLeft.Data() == aRight.Data();

	ret = ret && aLeft.Description() == aRight.Description();

	ret = ret && aLeft.Direction() == aRight.Direction();

	ret = ret && aLeft.Duration() == aRight.Duration();

	ret = ret && aLeft.DurationType() == aRight.DurationType();

	ret = ret && aLeft.EventType() == aRight.EventType();

	ret = ret && aLeft.Flags() == aRight.Flags();

	ret = ret && aLeft.Id() == aRight.Id();

	ret = ret && aLeft.Link() == aRight.Link();

	ret = ret && aLeft.Number() == aRight.Number();

	ret = ret && aLeft.RemoteParty() == aRight.RemoteParty();

	ret = ret && aLeft.Status() == aRight.Status();

	ret = ret && aLeft.Subject() == aRight.Subject();

	ret = ret && aLeft.Time() == aRight.Time();

	return ret;

	}

void TestStoreL(const CLogEvent& aEvent)

	{

//	const TInt size = aEvent.Size();

	//Store

	CBufFlat* buf = CBufFlat::NewL(0x100);

	CleanupStack::PushL(buf);

	RBufWriteStream write(*buf);

	write << aEvent;

	write.CommitL();

	//Restore

	CLogEvent* event = CLogEvent::NewL();

	CleanupStack::PushL(event);

	RBufReadStream read(*buf);

	read >> *event;

	TBool ret = CompareEvents(aEvent, *event);

	TEST(ret);

	CleanupStack::PopAndDestroy(2);

	}

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-1008

@SYMTestCaseDesc	    Tests for writing different events to a store

@SYMTestPriority 	    High

@SYMTestActions  	    Calls up TestStoreL() function

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestEventL()

//

//

//

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1008 "));

	CLogEvent* event1 = CLogEvent::NewL();

	CleanupStack::PushL(event1);

	// Event Id

	TEST(event1->Id() == KLogNullId);

	TestStoreL(*event1);

	event1->SetId(0x12345678);

	TEST(event1->Id() == 0x12345678);

	TestStoreL(*event1);

	event1->SetId(KMaxTInt32);

	TEST(event1->Id() == KMaxTInt32);

	TestStoreL(*event1);

	event1->SetId(0);

	TEST(event1->Id() == 0);

	TestStoreL(*event1);

	// Event type

	event1->SetEventType(TUid::Null());

	TestStoreL(*event1);

	event1->SetEventType(TUid::Uid(0x12345678));

	TEST(event1->EventType() == TUid::Uid(0x12345678));

	TestStoreL(*event1);

	event1->SetEventType(TUid::Uid(KMaxTInt32));

	TEST(event1->EventType() == TUid::Uid(KMaxTInt32));

	TestStoreL(*event1);

	event1->SetEventType(TUid::Null());

	TEST(event1->EventType() == TUid::Null());

	TestStoreL(*event1);

	// Remote Party

	TEST(event1->RemoteParty() == KNullDesC);

	TestStoreL(*event1);

	HBufC* buf = TestUtils::CreateBufLC(KLogMaxRemotePartyLength / 2);

	event1->SetRemoteParty(buf->Des());

	TEST(event1->RemoteParty() == buf->Des());

	CleanupStack::PopAndDestroy(); // buf

	TestStoreL(*event1);

	buf = TestUtils::CreateBufLC(KLogMaxRemotePartyLength);

	event1->SetRemoteParty(buf->Des());

	TEST(event1->RemoteParty() == buf->Des());

	CleanupStack::PopAndDestroy(); // buf

	TestStoreL(*event1);

	buf = TestUtils::CreateBufLC(KLogMaxRemotePartyLength * 2);

	event1->SetRemoteParty(buf->Des());

	TEST(event1->RemoteParty() == buf->Des().Left(KLogMaxRemotePartyLength));

	CleanupStack::PopAndDestroy(); // buf

	TestStoreL(*event1);

	event1->SetRemoteParty(KNullDesC);

	TEST(event1->RemoteParty() == KNullDesC);

	TestStoreL(*event1);

	// Direction

	TEST(event1->Direction() == KNullDesC);

	TestStoreL(*event1);

	buf = TestUtils::CreateBufLC(KLogMaxDirectionLength / 2);

	event1->SetDirection(buf->Des());

	TEST(event1->Direction() == buf->Des());

	CleanupStack::PopAndDestroy(); // buf

	TestStoreL(*event1);

	buf = TestUtils::CreateBufLC(KLogMaxDirectionLength);

	event1->SetDirection(buf->Des());

	TEST(event1->Direction() == buf->Des());

	CleanupStack::PopAndDestroy(); // buf

	TestStoreL(*event1);

	buf = TestUtils::CreateBufLC(KLogMaxDirectionLength * 2);

	event1->SetDirection(buf->Des());

	TEST(event1->Direction() == buf->Des().Left(KLogMaxDirectionLength));

	CleanupStack::PopAndDestroy(); // buf

	TestStoreL(*event1);

	event1->SetDirection(KNullDesC);

	TEST(event1->Direction() == KNullDesC);

	TestStoreL(*event1);

	// Time

	TTime time;

	time.UniversalTime();

	event1->SetTime(time);

	TEST(event1->Time() == time);

	TestStoreL(*event1);

	time.HomeTime();

	event1->SetTime(time);

	TEST(event1->Time() == time);

	TestStoreL(*event1);

	// Duration Type

	TEST(event1->DurationType() == KLogNullDurationType);

	event1->SetDurationType(0xf);

	TEST(event1->DurationType() == 0xf);

	TestStoreL(*event1);

	event1->SetDurationType(KMaxTInt8);

	TEST(event1->DurationType() == KMaxTInt8);

	TestStoreL(*event1);

	event1->SetDurationType(KLogNullDurationType);

	TEST(event1->DurationType() == KLogNullDurationType);

	TestStoreL(*event1);

	// Duration

	TEST(event1->Duration() == KLogNullDuration);

	event1->SetDuration(0x12345678);

	TEST(event1->Duration() == 0x12345678);

	TestStoreL(*event1);

	event1->SetDuration(KMaxTUint32);

	TEST(event1->Duration() == KMaxTUint32);

	TestStoreL(*event1);

	event1->SetDuration(KLogNullDuration);

	TEST(event1->Duration() == KLogNullDuration);

	TestStoreL(*event1);

	// Status

	TEST(event1->Status() == KNullDesC);

	buf = TestUtils::CreateBufLC(KLogMaxStatusLength / 2);

	event1->SetStatus(buf->Des());

	TEST(event1->Status() == buf->Des());

	CleanupStack::PopAndDestroy(); // buf

	TestStoreL(*event1);

	buf = TestUtils::CreateBufLC(KLogMaxStatusLength);

	event1->SetStatus(buf->Des());

	TEST(event1->Status() == buf->Des());

	CleanupStack::PopAndDestroy(); // buf

	TestStoreL(*event1);

	buf = TestUtils::CreateBufLC(KLogMaxStatusLength * 2);

	event1->SetStatus(buf->Des());

	TEST(event1->Status() == buf->Des().Left(KLogMaxStatusLength));

	CleanupStack::PopAndDestroy(); // buf

	TestStoreL(*event1);

	event1->SetStatus(KNullDesC);

	TEST(event1->Status() == KNullDesC);

	TestStoreL(*event1);

	// Subject

	TEST(event1->Subject() == KNullDesC);

	buf = TestUtils::CreateBufLC(KLogMaxSubjectLength / 2);

	event1->SetSubject(buf->Des());

	TEST(event1->Subject() == buf->Des());

	CleanupStack::PopAndDestroy(); // buf

	TestStoreL(*event1);

	buf = TestUtils::CreateBufLC(KLogMaxSubjectLength);

	event1->SetSubject(buf->Des());

	TEST(event1->Subject() == buf->Des());

	CleanupStack::PopAndDestroy(); // buf

	TestStoreL(*event1);

	buf = TestUtils::CreateBufLC(KLogMaxSubjectLength * 2);

	event1->SetSubject(buf->Des());

	TEST(event1->Subject() == buf->Des().Left(KLogMaxSubjectLength));

	CleanupStack::PopAndDestroy(); // buf

	TestStoreL(*event1);

	event1->SetSubject(KNullDesC);

	TEST(event1->Subject() == KNullDesC);

	TestStoreL(*event1);

	// Number

	TEST(event1->Number() == KNullDesC);

	buf = TestUtils::CreateBufLC(KLogMaxNumberLength / 2);

	event1->SetNumber(buf->Des());

	TEST(event1->Number() == buf->Des());

	CleanupStack::PopAndDestroy(); // buf

	TestStoreL(*event1);

	buf = TestUtils::CreateBufLC(KLogMaxNumberLength);

	event1->SetNumber(buf->Des());

	TEST(event1->Number() == buf->Des());

	CleanupStack::PopAndDestroy(); // buf

	TestStoreL(*event1);

	buf = TestUtils::CreateBufLC(KLogMaxNumberLength * 2);

	event1->SetNumber(buf->Des());

	TEST(event1->Number() == buf->Des().Left(KLogMaxNumberLength));

	CleanupStack::PopAndDestroy(); // buf

	TestStoreL(*event1);

	event1->SetNumber(KNullDesC);

	TEST(event1->Number() == KNullDesC);

	TestStoreL(*event1);

	// Contact

	TEST(event1->Contact() == KLogNullContactId);

	event1->SetContact(0x12345678);

	TEST(event1->Contact() == 0x12345678);

	TestStoreL(*event1);

	event1->SetContact(KMaxTInt32);

	TEST(event1->Contact() == KMaxTInt32);

	TestStoreL(*event1);

	event1->SetContact(KLogNullContactId);

	TEST(event1->Contact() == KLogNullContactId);

	TestStoreL(*event1);

	event1->SetContact(KMinTInt32);

	TEST(event1->Contact() == KMinTInt32);

	TestStoreL(*event1);

	// Link

	TEST(event1->Link() == KLogNullLink);

	event1->SetLink(0x12345678);

	TEST(event1->Link() == 0x12345678);

	TestStoreL(*event1);

	event1->SetLink(KMaxTUint32);

	TEST(event1->Link() == KMaxTUint32);

	TestStoreL(*event1);

	event1->SetLink(KLogNullLink);

	TEST(event1->Link() == KLogNullLink);

	// Description

	TEST(event1->Description() == KNullDesC);

	buf = TestUtils::CreateBufLC(KLogMaxDescriptionLength / 2);

	event1->SetDescription(buf->Des());

	TEST(event1->Description() == buf->Des());

	CleanupStack::PopAndDestroy(); // buf

	TestStoreL(*event1);

	buf = TestUtils::CreateBufLC(KLogMaxDescriptionLength);

	event1->SetDescription(buf->Des());

	TEST(event1->Description() == buf->Des());

	CleanupStack::PopAndDestroy(); // buf

	TestStoreL(*event1);

	buf = TestUtils::CreateBufLC(KLogMaxDescriptionLength * 2);

	event1->SetDescription(buf->Des());

	TEST(event1->Description() == buf->Des().Left(KLogMaxDescriptionLength));

	CleanupStack::PopAndDestroy(); // buf

	TestStoreL(*event1);

	event1->SetDescription(KNullDesC);

	TEST(event1->Description() == KNullDesC);

	// Flags

	TEST(event1->Flags() == KLogNullFlags);

	event1->SetFlags(1);

	TEST(event1->Flags() == 1);

	TestStoreL(*event1);

	event1->SetFlags(2);

	TEST(event1->Flags() == 3);

	event1->SetFlags(4);

	TEST(event1->Flags() == 7);

	event1->SetFlags(8);

	TEST(event1->Flags() == KLogFlagsMask);

	event1->ClearFlags(8);

	TEST(event1->Flags() == 7);

	event1->ClearFlags(4);

	TEST(event1->Flags() == 3);

	event1->ClearFlags(2);

	TEST(event1->Flags() == 1);

	event1->ClearFlags(1);

	TEST(event1->Flags() == KLogNullFlags);

	event1->SetFlags(1);

	TEST(event1->Flags() == 1);

	event1->SetFlags(3);

	TEST(event1->Flags() == 3);

	event1->SetFlags(7);

	TEST(event1->Flags() == 7);

	event1->SetFlags(15);

	event1->SetFlags(KLogFlagsMask);

	TEST(event1->Flags() == KLogFlagsMask);

	event1->ClearFlags(KLogFlagsMask);

	TEST(event1->Flags() == KLogNullFlags);

	event1->SetFlags(0x5);

	TEST(event1->Flags() == 0x5);

	event1->SetFlags(0xA);

	TEST(event1->Flags() == KLogFlagsMask);

	event1->ClearFlags(0x5);

	TEST(event1->Flags() == 0xA);

	event1->ClearFlags(0xA);

	TEST(event1->Flags() == KLogNullFlags);

	// Data

	TEST(event1->Data() == KNullDesC8);

	HBufC8* buf8;

	buf8 = TestUtils::CreateBuf8LC(100);

	event1->SetDataL(buf8->Des());

	TEST(event1->Data() == buf8->Des());

	CleanupStack::PopAndDestroy();

	TestStoreL(*event1);

	buf8 = TestUtils::CreateBuf8LC(200);

	event1->SetDataL(buf8->Des());

	TEST(event1->Data() == buf8->Des());

	CleanupStack::PopAndDestroy();

	TestStoreL(*event1);

	buf8 = TestUtils::CreateBuf8LC(400);

	event1->SetDataL(buf8->Des());

	TEST(event1->Data() == buf8->Des());

	CleanupStack::PopAndDestroy();

	TestStoreL(*event1);

	event1->SetDataL(KNullDesC8);

	TEST(event1->Data() == KNullDesC8);

	// streaming

	TFileName storename = _L("c:\\T_LOGEVENT_DATA");

	TUid uid={0x12345678};

	// create a store

	theFs.Delete(storename);

	CDictionaryFileStore* store = CDictionaryFileStore::OpenLC(theFs, storename, uid);

	RDictionaryWriteStream write;

	RDictionaryReadStream read;

	event1->SetDataL(KNullDesC8);

	uid.iUid++;

	write.AssignL(*store, uid);

	write << event1->Data();

	write.CommitL();

	write.Close();

	read.OpenL(*store, uid);

	event1->SetDataL(read, 0);

	read.Close();

	TEST(event1->Data() == KNullDesC8);

	buf8 = TestUtils::CreateBuf8LC(100);

	event1->SetDataL(buf8->Des());

	uid.iUid++;

	write.AssignL(*store, uid);

	write.WriteL(event1->Data());

	write.CommitL();

	write.Close();

	read.OpenL(*store, uid);

	event1->SetDataL(read, 100);

	read.Close();

	TEST(event1->Data() == buf8->Des());

	CleanupStack::PopAndDestroy(); // buf8

	buf8 = TestUtils::CreateBuf8LC(200);

	event1->SetDataL(buf8->Des());

	uid.iUid++;

	write.AssignL(*store, uid);

	write.WriteL(event1->Data());

	write.CommitL();

	write.Close();

	read.OpenL(*store, uid);

	event1->SetDataL(read, 200);

	read.Close();

	TEST(event1->Data() == buf8->Des());

	CleanupStack::PopAndDestroy(); // buf8

	buf8 = TestUtils::CreateBuf8LC(400);

	event1->SetDataL(buf8->Des());

	uid.iUid++;

	write.AssignL(*store, uid);

	write.WriteL(event1->Data());

	write.CommitL();

	write.Close();

	read.OpenL(*store, uid);

	event1->SetDataL(read, 400);

	read.Close();

	TEST(event1->Data() == buf8->Des());

	CleanupStack::PopAndDestroy(2); // buf8, store

	// Copying

	event1->SetId(0x12345678);

	event1->SetEventType(TUid::Uid(0x12345678));

	buf = TestUtils::CreateBufLC(KLogMaxRemotePartyLength / 2);

	event1->SetRemoteParty(buf->Des());

	TEST(event1->RemoteParty() == buf->Des());

	CleanupStack::PopAndDestroy(); // buf

	buf = TestUtils::CreateBufLC(KLogMaxDirectionLength / 2);

	event1->SetDirection(buf->Des());

	TEST(event1->Direction() == buf->Des());

	CleanupStack::PopAndDestroy(); // buf

	event1->SetDurationType(0xf);

	TEST(event1->DurationType() == 0xf);

	event1->SetDuration(0x12345678);

	TEST(event1->Duration() == 0x12345678);

	buf = TestUtils::CreateBufLC(KLogMaxStatusLength / 2);

	event1->SetStatus(buf->Des());

	TEST(event1->Status() == buf->Des());

	CleanupStack::PopAndDestroy(); // buf

	buf = TestUtils::CreateBufLC(KLogMaxSubjectLength / 2);

	event1->SetSubject(buf->Des());

	TEST(event1->Subject() == buf->Des());

	CleanupStack::PopAndDestroy(); // buf

	buf = TestUtils::CreateBufLC(KLogMaxNumberLength / 2);

	event1->SetNumber(buf->Des());

	TEST(event1->Number() == buf->Des());

	CleanupStack::PopAndDestroy(); // buf

	event1->SetContact(0x12345678);

	TEST(event1->Contact() == 0x12345678);

	event1->SetLink(0x12345678);

	TEST(event1->Link() == 0x12345678);

	buf = TestUtils::CreateBufLC(KLogMaxDescriptionLength / 2);