diff -r 000000000000 -r 08ec8eefde2f loggingservices/eventlogger/test/src/t_logevent.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/loggingservices/eventlogger/test/src/t_logevent.cpp	Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,924 @@
+// 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);
+	event1->SetDescription(buf->Des());
+	TEST(event1->Description() == buf->Des());
+	CleanupStack::PopAndDestroy(); // buf
+
+	buf8 = TestUtils::CreateBuf8LC(200);
+	event1->SetDataL(buf8->Des());
+	TEST(event1->Data() == buf8->Des());
+	CleanupStack::PopAndDestroy();
+
+	CLogEvent* event2 = CLogEvent::NewL();
+	CleanupStack::PushL(event2);
+	TEST(!TestUtils::EventsEqual(*event1, *event2));
+
+	event2->CopyL(*event1);
+	TEST(TestUtils::EventsEqual(*event1, *event2));
+	
+	CleanupStack::PopAndDestroy(); // event2;
+
+	event2 = CLogEvent::NewL();
+	CleanupStack::PushL(event2);
+	TEST(!TestUtils::EventsEqual(*event1, *event2));
+
+	event1->CopyL(*event2);
+	TEST(TestUtils::EventsEqual(*event1, *event2));
+
+	CleanupStack::PopAndDestroy(2); // event1, event2;
+
+	::DeleteDataFile(storename);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-1009
+@SYMTestCaseDesc	    Tests for CLogEvent::NewL(),SetDataL() functions
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for creation of log event on heap and 
+                        test for setting  event specific data from the specified stream and try to read the data back.
+                        Check for memory errors
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestEventWithHeapFailL()
+//
+//
+//
+
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1009 "));
+#ifdef _DEBUG
+	TInt failCount = 0;
+#endif
+	TInt error;
+	TBool finished = EFalse;
+
+	CLogEvent* event = NULL;
+
+	while(!finished)
+		{
+		__UHEAP_FAILNEXT(failCount++);
+
+		TRAP(error, event = CLogEvent::NewL());
+		
+		__UHEAP_RESET;
+
+		if (error == KErrNone)
+			{
+			finished = ETrue;
+			CleanupStack::PushL(event);
+			}
+		else
+			TEST2(error, KErrNoMemory);
+		}
+
+	_LIT8(KDataTest1, "01234567890123456789");
+	_LIT8(KDataTest2, "012345678901234567890123456789");
+
+	finished = EFalse;
+#ifdef _DEBUG
+	failCount = 0;
+#endif
+	event->SetDataL(KNullDesC8);
+
+	while(!finished)
+		{
+		__UHEAP_FAILNEXT(failCount++);
+
+		TRAP(error, event->SetDataL(KDataTest1));
+
+		__UHEAP_RESET;
+
+		if (error == KErrNone)
+			{
+			finished = ETrue;
+			TEST(event->Data() == KDataTest1);
+			}
+		else
+			{
+			TEST2(error, KErrNoMemory);
+			TEST(event->Data() == KNullDesC8);
+			}
+		}
+
+	finished = EFalse;
+#ifdef _DEBUG
+	failCount = 0;
+#endif
+	event->SetDataL(KNullDesC8);
+
+	while(!finished)
+		{
+		__UHEAP_FAILNEXT(failCount++);
+
+		TRAP(error, event->SetDataL(KDataTest2));
+
+		__UHEAP_RESET;
+
+		if (error == KErrNone)
+			{
+			finished = ETrue;
+			TEST(event->Data() == KDataTest2);
+			}
+		else
+			{
+			TEST2(error, KErrNoMemory);
+			TEST(event->Data() == KNullDesC8);
+			}
+		}
+
+	finished = EFalse;
+#ifdef _DEBUG
+	failCount = 0;
+#endif
+	event->SetDataL(KNullDesC8);
+
+	// Check we don't get any more failures
+	__UHEAP_FAILNEXT(0);
+	event->SetDataL(KDataTest2);
+	TEST(event->Data() == KDataTest2);
+	event->SetDataL(KDataTest1);
+	TEST(event->Data() == KDataTest1);
+	event->SetDataL(KNullDesC8);
+	TEST(event->Data() == KNullDesC8);
+	__UHEAP_RESET;
+
+	// streaming
+	TFileName storename = _L("c:\\T_BASIC_DATA");
+	TUid uid={0x12345678};
+
+	// create a store
+	theFs.Delete(storename);
+	CDictionaryFileStore* store = CDictionaryFileStore::OpenLC(theFs, storename, uid);
+	
+	RDictionaryWriteStream write;
+	RDictionaryReadStream read;
+
+	uid.iUid++;
+	write.AssignL(*store, uid);
+	write << KNullDesC8;
+	write.CommitL();
+	write.Close();
+
+	read.OpenL(*store, uid);
+
+#ifdef _DEBUG
+	failCount = 0;
+#endif
+	finished = EFalse;
+
+	__UHEAP_FAILNEXT(0);
+	event->SetDataL(read, 0);
+	__UHEAP_RESET;
+
+	read.Close();	
+	TEST(event->Data() == KNullDesC8);
+
+	HBufC8* buf8 = TestUtils::CreateBuf8LC(100);
+
+	uid.iUid++;
+	write.AssignL(*store, uid);
+	write.WriteL(buf8->Des());
+	write.CommitL();
+	write.Close();
+
+	read.OpenL(*store, uid);
+
+	while(!finished)
+		{
+		__UHEAP_FAILNEXT(failCount++);
+
+		TRAP(error, event->SetDataL(read, 100));
+
+		__UHEAP_RESET;
+
+		if (error == KErrNone)
+			{
+			TEST(event->Data() == buf8->Des());
+			read.Close();
+			finished = ETrue;
+			}
+		else
+			{
+			TEST2(error, KErrNoMemory);
+			TEST(event->Data() == KNullDesC8);
+			}
+		}
+
+	event->SetId(0x12345678);
+	event->SetEventType(TUid::Uid(0x12345678));
+
+	HBufC* buf = TestUtils::CreateBufLC(KLogMaxRemotePartyLength / 2);
+	event->SetRemoteParty(buf->Des());
+	CleanupStack::PopAndDestroy(); // buf
+
+	buf = TestUtils::CreateBufLC(KLogMaxDirectionLength / 2);
+	event->SetDirection(buf->Des());
+	CleanupStack::PopAndDestroy(); // buf
+
+	TTime time;
+
+	time.UniversalTime();
+	event->SetTime(time);
+	TEST(event->Time() == time);
+
+	event->SetDurationType(0xf);
+	event->SetDuration(0x12345678);
+
+	buf = TestUtils::CreateBufLC(KLogMaxStatusLength / 2);
+	event->SetStatus(buf->Des());
+	CleanupStack::PopAndDestroy(); // buf
+
+	buf = TestUtils::CreateBufLC(KLogMaxSubjectLength / 2);
+	event->SetSubject(buf->Des());
+	CleanupStack::PopAndDestroy(); // buf
+
+	buf = TestUtils::CreateBufLC(KLogMaxNumberLength / 2);
+	event->SetNumber(buf->Des());
+	CleanupStack::PopAndDestroy(); // buf
+
+	event->SetContact(0x12345678);
+	event->SetLink(0x12345678);
+
+	buf = TestUtils::CreateBufLC(KLogMaxDescriptionLength / 2);
+	event->SetDescription(buf->Des());
+	CleanupStack::PopAndDestroy(); // buf
+
+	event->SetFlags(0xA);
+
+	buf8 = TestUtils::CreateBuf8LC(100);
+	event->SetDataL(buf8->Des());
+	TEST(event->Data() == buf8->Des());
+	CleanupStack::PopAndDestroy(); // buf8
+
+	CLogEvent* event1 = CLogEvent::NewL();
+	CleanupStack::PushL(event1);
+
+	CLogEvent* event2 = CLogEvent::NewL();
+	CleanupStack::PushL(event2);
+
+	TEST(TestUtils::EventsEqual(*event1, *event2));
+
+	finished = EFalse;
+#ifdef _DEBUG
+	failCount = 0;
+#endif
+
+	while(!finished)
+		{
+		__UHEAP_FAILNEXT(failCount++);
+
+		TRAP(error, event1->CopyL(*event));
+
+		__UHEAP_RESET;
+
+		if (error == KErrNone)
+			{
+			TEST(!TestUtils::EventsEqual(*event1, *event2));
+			TEST(TestUtils::EventsEqual(*event1, *event));
+			finished = ETrue;
+			}
+		else
+			{
+			TEST2(error, KErrNoMemory);
+			TEST(TestUtils::EventsEqual(*event1, *event2));
+			TEST(!TestUtils::EventsEqual(*event1, *event));
+			}
+		}
+
+	CleanupStack::PopAndDestroy(5); // buf8, store, event, event1, event2
+	::DeleteDataFile(storename);
+	}
+
+/**
+@SYMTestCaseID          SYSLIB-LOGENG-CT-1010
+@SYMTestCaseDesc	    Tests for CLogEvent::NewL(),CLogEvent::SetDataL() functions
+@SYMTestPriority 	    High
+@SYMTestActions  	    Tests for setting event specific data read from the file and try to read the data back from the event.
+                        Check for memory errors
+@SYMTestExpectedResults Test must not fail
+@SYMREQ                 REQ0000
+*/
+LOCAL_C void TestEventWithFileFailL()
+//
+//
+//
+	{
+	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1010 "));
+	CLogEvent* event = CLogEvent::NewL();
+	CleanupStack::PushL(event);
+
+	// streaming
+	TFileName storename = _L("c:\\T_BASIC_DATA");
+	TUid uid={0x12345678};
+
+	// create a store
+	theFs.Delete(storename);
+	CDictionaryFileStore* store = CDictionaryFileStore::OpenLC(theFs, storename, uid);
+	
+	RDictionaryWriteStream write;
+	RDictionaryReadStream read;
+
+	uid.iUid++;
+	write.AssignL(*store, uid);
+	write << KNullDesC8;
+	write.CommitL();
+	write.Close();
+
+	read.OpenL(*store, uid);
+
+	TInt failCount = 0;
+	TBool finished = EFalse;
+	TInt error;
+
+	theFs.SetErrorCondition(KErrGeneral, 0);
+	event->SetDataL(read, 0);
+	theFs.SetErrorCondition(KErrNone, 10000);
+
+	read.Close();
+	TEST(event->Data() == KNullDesC8);
+
+	HBufC8* buf8 = TestUtils::CreateBuf8LC(100);
+
+	uid.iUid++;
+	write.AssignL(*store, uid);
+	write.WriteL(buf8->Des());
+	write.CommitL();
+	write.Close();
+
+	while(!finished)
+		{
+		read.OpenL(*store, uid);
+		theFs.SetErrorCondition(KErrGeneral, failCount++);
+
+		TRAP(error, event->SetDataL(read, 100));
+
+		theFs.SetErrorCondition(KErrGeneral, 10000);
+
+		read.Close();
+
+		if (error == KErrNone)
+			{
+			TEST(event->Data() == buf8->Des());
+			finished = ETrue;
+			}
+		else
+			{
+			TEST2(error, KErrGeneral);
+			TEST(event->Data() == KNullDesC8);
+			}
+		}
+
+	CleanupStack::PopAndDestroy(3); // buf8, store, event
+	::DeleteDataFile(storename);
+	}
+
+void doTestsL()
+//
+//
+//
+	{
+	TestUtils::Initialize(_L("T_LOGEVENT"));
+
+	test.Start(_L("Event"));
+//	TestServerL();
+	
+
+	TestEventL();
+	theLog.Write(_L8("Test 1 OK\n"));
+
+	test.Next(_L("Event with heap failure"));
+	TestEventWithHeapFailL();
+	theLog.Write(_L8("Test 2 OK\n"));
+
+	test.Next(_L("Event with file failure"));
+	TestEventWithFileFailL();
+	theLog.Write(_L8("Test 3 OK\n"));
+	}
+