// Copyright (c) 2002-2010 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 "t_logutil2.h"

 #include <logview.h>

 RTest TheTest(_L("t_lognotify"));

 _LIT(KTestRemoteParty1, "Remote Party");

 _LIT(KTestDirection1, "Direction");

 const TLogDurationType KTestDurationType1 = 1;

 const TLogDuration KTestDuration1 = 0x1234;

 _LIT(KTestStatus1, "Status");

 _LIT(KTestSubject1, "Subject");

 _LIT(KTestNumber1, "TheNumber");

 const TLogContactItemId KTestContact1 = 0x1234;

 const TLogLink KTestLink1 = 0x1234;

 _LIT8(KTestData1, "ABCDEFGH");

 const TLogFlags KTestFlags1 = 0x5;

 /**

 @SYMTestCaseID          SYSLIB-LOGENG-CT-0926

 @SYMTestCaseDesc	    Tests for CLogClient::NotifyChange() function

 @SYMTestPriority 	    High

 @SYMTestActions  	    Tests for notification of changes to the logengine database.

                         Add events within the time intervals ,check for the notification of an event

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestNotificationL()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0926 "));

 	CLogClient* client = CLogClient::NewL(theFs);

 	CleanupStack::PushL(client);

 	CTestActive* active1 = new(ELeave)CTestActive;

 	CleanupStack::PushL(active1);

 	CTestActive* active2 = new(ELeave)CTestActive;

 	CleanupStack::PushL(active2);

 	CLogEvent* event = CLogEvent::NewL();

 	CleanupStack::PushL(event);

 	event->SetEventType(KLogCallEventTypeUid);

 	event->SetRemoteParty(KTestRemoteParty1);

 	event->SetDirection(KTestDirection1);

 	event->SetDurationType(KTestDurationType1);

 	event->SetDuration(KTestDuration1);

 	event->SetStatus(KTestStatus1);

 	event->SetSubject(KTestSubject1);

 	event->SetNumber(KTestNumber1);

 	event->SetContact(KTestContact1);

 	event->SetLink(KTestLink1);

 	event->SetDataL(KTestData1);

 	event->SetFlags(KTestFlags1);

 	// *** Notification when change made - no delay

 	active1->StartL();

 	client->NotifyChange(0, active1->iStatus);

 	// Add an event

 	active2->StartL();

 	client->AddEvent(*event, active2->iStatus);

 	// Not sure which will finish first

 	CActiveScheduler::Start();

 	if (!active1->IsActive())

 		{

 		TEST(active2->IsActive());

 		TEST(active1->iStatus.Int() >= 0);

 		CActiveScheduler::Start();

 		TEST2(active2->iStatus.Int(), KErrNone);

 		}

 	else

 		{

 		TEST2(active2->iStatus.Int(), KErrNone);

 		CActiveScheduler::Start();

 		TEST(active1->iStatus.Int() >= 0);

 		}

 	// Remember the time

 	TTime before;

 	before.UniversalTime();

 	const TTimeIntervalMicroSeconds32 delay = 3000000;

 	// *** Notification when change made - with long delay

 	active1->StartL();

 	client->NotifyChange(delay, active1->iStatus);

 	// Add an event

 	active2->StartL();

 	client->AddEvent(*event, active2->iStatus);

 	// We can be fairly certain that the function will complete first

 	CActiveScheduler::Start();

 	TEST2(active2->iStatus.Int(), KErrNone);

 	TEST(active1->IsActive());

 	CActiveScheduler::Start();

 	TEST(active1->iStatus.Int() >= 0);

 	User::After(1000000);

 	// Check delay

 	TTime after;

 	after.UniversalTime();

 	TEST(before + delay <= after);

 	before.UniversalTime();

 	// *** Notification when change made - with long delay - multiple changes

 	active1->StartL();

 	client->NotifyChange(delay, active1->iStatus);

 	// Add an event

 	active2->StartL();

 	client->AddEvent(*event, active2->iStatus);

 	// The function should complete

 	CActiveScheduler::Start();

 	TEST(active1->IsActive());

 	TEST2(active2->iStatus.Int(), KErrNone);

 	// Change the event

 	active2->StartL();

 	client->ChangeEvent(*event, active2->iStatus);

 	// The function should complete

 	CActiveScheduler::Start();

 	TEST(active1->IsActive());

 	TEST2(active2->iStatus.Int(), KErrNone);

 	// The notification should complete

 	CActiveScheduler::Start();

 	TEST(active1->iStatus.Int() >= 0);

 #ifdef __WINS__

 	User::After(1000000);

 #endif

 	// Check delay

 	after.UniversalTime();

 	TEST(before + TTimeIntervalMicroSeconds32(delay) <= after);

 	// *** Notification when change made - after long delay

 	active1->StartL();

 	client->NotifyChange(delay, active1->iStatus);

 	// Wait around for a time equal to the delay

 	CTestTimer* timer = CTestTimer::NewL();

 	timer->After(delay);

 	CActiveScheduler::Start();

 	delete timer;

 	// Add an event

 	active2->StartL();

 	client->AddEvent(*event, active2->iStatus);

 	// Not sure which will finish first

 	CActiveScheduler::Start();

 	if (!active1->IsActive())

 		{

 		TEST(active2->IsActive());

 		TEST(active1->iStatus.Int() >= 0);

 		CActiveScheduler::Start();

 		TEST2(active2->iStatus.Int(), KErrNone);

 		}

 	else

 		{

 		TEST2(active2->iStatus.Int(), KErrNone);

 		CActiveScheduler::Start();

 		TEST(active1->iStatus.Int() >= 0);

 		}

 	CleanupStack::PopAndDestroy(4); // event, active2, active1, client

 	}

 /**

 @SYMTestCaseID          SYSLIB-LOGENG-CT-0927

 @SYMTestCaseDesc	    Tests for CLogClient::NotifyChangeCancel() function

 @SYMTestPriority 	    High

 @SYMTestActions  	    Tests for cancelling of any outstanding notification requests for changes to log engine database

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestCancelNotificationL()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0927 "));

 	CLogClient* client = CLogClient::NewL(theFs);

 	CleanupStack::PushL(client);

 	CTestActive* active1 = new(ELeave)CTestActive;

 	CleanupStack::PushL(active1);

 	// *** Cancel without delay

 	active1->StartL();

 	client->NotifyChange(0, active1->iStatus);

 	client->NotifyChangeCancel();

 	CActiveScheduler::Start();

 	TEST2(active1->iStatus.Int(), KErrCancel);

 	const TInt delay = 3000000;

 	// *** Cancel with delay	

 	active1->StartL();

 	client->NotifyChange(delay, active1->iStatus);

 	// Wait around for a bit

 	CTestTimer* timer = CTestTimer::NewL();

 	timer->After(delay / 2);

 	CActiveScheduler::Start();

 	delete timer;

 	client->NotifyChangeCancel();

 	CActiveScheduler::Start();

 	TEST2(active1->iStatus.Int(), KErrCancel);

 	// *** Cancel with long delay	

 	active1->StartL();

 	client->NotifyChange(delay, active1->iStatus);

 	// Wait around for a bit

 	timer = CTestTimer::NewL();

 	timer->After(delay * 2);

 	CActiveScheduler::Start();

 	delete timer;

 	client->NotifyChangeCancel();

 	CActiveScheduler::Start();

 	TEST2(active1->iStatus.Int(), KErrCancel);

 	// *** Cancel after change

 	CLogEvent* event = CLogEvent::NewL();

 	CleanupStack::PushL(event);

 	event->SetEventType(KLogCallEventTypeUid);

 	active1->StartL();

 	client->NotifyChange(delay, active1->iStatus);

 	CTestActive* active2 = new(ELeave)CTestActive;

 	CleanupStack::PushL(active2);

 	active2->StartL();

 	client->AddEvent(*event, active2->iStatus);

 	CActiveScheduler::Start();

 	TEST(active1->IsActive());

 	TEST2(active2->iStatus.Int(), KErrNone);

 	client->NotifyChangeCancel();

 	CActiveScheduler::Start();

 	TEST2(active1->iStatus.Int(), KErrCancel);

 	// *** Cancel after change and delay

 	active1->StartL();

 	client->NotifyChange(delay, active1->iStatus);

 	// Wait around for a bit

 	timer = CTestTimer::NewL();

 	timer->After(delay / 2);

 	CActiveScheduler::Start();

 	delete timer;

 	active2->StartL();

 	client->AddEvent(*event, active2->iStatus);

 	CActiveScheduler::Start();

 	TEST(active1->IsActive());

 	TEST2(active2->iStatus.Int(), KErrNone);

 	client->NotifyChangeCancel();

 	CActiveScheduler::Start();

 	TEST2(active1->iStatus.Int(), KErrCancel);

 	// *** Cancel after change and delay

 	active1->StartL();

 	client->NotifyChange(delay, active1->iStatus);

 	active2->StartL();

 	client->AddEvent(*event, active2->iStatus);

 	CActiveScheduler::Start();

 	TEST(active1->IsActive());

 	TEST2(active2->iStatus.Int(), KErrNone);

 	// Wait around for a bit

 	timer = CTestTimer::NewL();

 	timer->After(delay / 2);

 	CActiveScheduler::Start();

 	delete timer;

 	client->NotifyChangeCancel();

 	CActiveScheduler::Start();

 	TEST2(active1->iStatus.Int(), KErrCancel);

 	// *** Cancel when not active

 	client->NotifyChangeCancel();

 	CleanupStack::PopAndDestroy(4); // active2, event, active, client

 	}

 /**

 @SYMTestCaseID          SYSLIB-LOGENG-CT-0928

 @SYMTestCaseDesc	    Tests for notification requests on view purge

 @SYMTestPriority 	    High

 @SYMTestActions  	    Notify changes on log view event

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestViewPurgeNotifyL()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0928 "));

 	CTestTimer* timer = CTestTimer::NewL();

 	CleanupStack::PushL(timer);

 	CTestActive* active = new(ELeave)CTestActive();

 	CleanupStack::PushL(active);

 	CLogClient* client = CLogClient::NewL(theFs);

 	CleanupStack::PushL(client);

 	CLogViewEvent* view = CLogViewEvent::NewL(*client);

 	CleanupStack::PushL(view);

 	CLogFilter* filter = CLogFilter::NewL();

 	CleanupStack::PushL(filter);

 	CTestActive* notify = new(ELeave)CTestActive;

 	CleanupStack::PushL(notify);

 	// Start notifier

 	notify->StartL();

 	client->NotifyChange(1000000, notify->iStatus);

 	// Wait for 10 seconds

 	TEST(notify->IsActive());

 	timer = CTestTimer::NewL();

 	timer->After(7000000);

 	CActiveScheduler::Start();

 	delete timer;

 	// Setup a view

 	TEST(notify->IsActive());

 	if (view->SetFilterL(*filter, active->iStatus))

 		{

 		active->StartL();

 		CActiveScheduler::Start();

 		TEST(view->CountL() > 0);

 		}

 	// Wait for 10 seconds

 	TEST(notify->IsActive());

 	timer = CTestTimer::NewL();

 	timer->After(10000000);

 	CActiveScheduler::Start();

 	delete timer;

 	// We shouldn't be notified because nothing has changed

 	TEST(notify->IsActive());

 	client->NotifyChangeCancel();

 	CActiveScheduler::Start();

 	TEST2(notify->iStatus.Int(), KErrCancel);

 	CleanupStack::PopAndDestroy(6); // notify, client, filter, view, active, timer

 	}

 /**

 INC045485 - AV20 Messaging App crashes when attempting to write New SMS

 @SYMTestCaseID          SYSLIB-LOGENG-CT-0929

 @SYMTestCaseDesc	    Tests for defect number INC045485L.

 @SYMTestPriority 	    High

 @SYMTestActions  	    Tests by adding a fax event type

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void INC045485L()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0929 "));

 	const TInt KEventCnt = 5;//test events count

 	const TInt KSizeOfEventData = 400;//should be bigger than KLogSizeOfEventGuess constant

 	//Create client, active, event

 	CLogClient* client = CLogClient::NewL(theFs);

 	CleanupStack::PushL(client);

 	CTestActive* active = new (ELeave) CTestActive;

 	CleanupStack::PushL(active);

 	CLogEvent* event = CLogEvent::NewL();

 	CleanupStack::PushL(event);

 	//Add KEventCnt events

 	for(TInt i=0;i<KEventCnt;++i)

 		{

 		event->SetId(0x13579 + i);

 		event->SetEventType(KLogFaxEventTypeUid);

 		TUint8 buf[KSizeOfEventData];

 		Mem::Fill(buf, KSizeOfEventData, TChar('1' + i));

 		TPtr8 ptr(buf, KSizeOfEventData, KSizeOfEventData);

 		event->SetDataL(ptr);

 		//

 		active->StartL();

 		client->AddEvent(*event, active->iStatus);

 		CActiveScheduler::Start();

 		TEST(!active->IsActive());

 		client->Cancel();

 		TEST2(active->iStatus.Int(), KErrNone);

 		}

 	//Create LogViewEvent, CLogFilter

 	CLogViewEvent* view = CLogViewEvent::NewL(*client);

 	CleanupStack::PushL(view);

 	CLogFilter* filter = CLogFilter::NewL();

 	CleanupStack::PushL(filter);

 	filter->SetEventType(KLogFaxEventTypeUid);//the same as the type UID of added events

 	//Filter the events

 	if(view->SetFilterL(*filter, active->iStatus))

 		{

 		active->StartL();

 		CActiveScheduler::Start();

 		TEST(view->CountL() == KEventCnt);

 		}

 	//Visit the events

 	TInt j = 0;

 	TEST(view->FirstL(active->iStatus));

 	do

 		{

 		active->StartL();

 		CActiveScheduler::Start();

 		TEST2(active->iStatus.Int(), KErrNone);//If the defect is not fixed this check fails with "KErrOverflow"

 		const CLogEvent& e = view->Event();

 		TheTest.Printf(_L("View Entry[%d]: Id:%d, Type:%x\n"), j, e.Id(), e.EventType().iUid);

 		const TDesC8& data = e.Data();

 		TEST(data.Length() == KSizeOfEventData);

 		//Touch the data.

 		for(TInt k=0;k<KSizeOfEventData;++k)

 			{

 			TChar c = data[k];

 			TEST(c >= TChar('1') && c < TChar('1' + KEventCnt));

 			}

 		++j;

 		}

 	while(view->NextL(active->iStatus));

 	//Destroy filter, view, event, active, client

 	CleanupStack::PopAndDestroy(filter);

 	CleanupStack::PopAndDestroy(view);

 	CleanupStack::PopAndDestroy(event);

 	CleanupStack::PopAndDestroy(active);

 	CleanupStack::PopAndDestroy(client);

 	}

 //DEF060381  Propagated: Receiving Chinese SMSes causes the battery to drain too fast 

 static void DEF060381L()

 	{

 	const TInt KSizeOfEventData = 1025; //should be bigger than KLogSizeOfEventGuess constant

 	//Create two clients. The first one will be used to send one message to the server,

 	//which length is too big. The second client will be used to receive the message from

 	//the server.

 	//If the defect is not fixed, the function hangs and its return point is never reached.

 	CLogClient* client1 = CLogClient::NewL(theFs);

 	CleanupStack::PushL(client1);

 	CLogClient* client2 = CLogClient::NewL(theFs);

 	CleanupStack::PushL(client2);

 	CTestActive* active = new (ELeave) CTestActive;

 	CleanupStack::PushL(active);

 	//Create one SMS event, which holds a block of data with size bigger than the default 

 	//size of the client side buffer (KLogSizeOfEventGuess).

 	CLogEvent* event = CLogEvent::NewL();

 	CleanupStack::PushL(event);

 	event->SetId(0x9991118);

 	event->SetEventType(KLogShortMessageEventTypeUid);

 	TUint8 buf[KSizeOfEventData];

 	for(TInt i=0;i<KSizeOfEventData;++i)

 		{

 		buf[i] = static_cast <TUint8> (i % 256);

 		}

 	TPtr8 ptr(buf, KSizeOfEventData, KSizeOfEventData);

 	event->SetDataL(ptr);

 	//Send the created event to the server unsing the first client.

 	active->StartL();

 	client1->AddEvent(*event, active->iStatus);

 	CActiveScheduler::Start();

 	TEST(!active->IsActive());

 	TEST2(active->iStatus.Int(), KErrNone);

 	//Create a view using the second client.

 	//Create a filter for SMS messages.

 	CLogViewEvent* view = CLogViewEvent::NewL(*client2);

 	CleanupStack::PushL(view);

 	CLogFilter* filter = CLogFilter::NewL();

 	CleanupStack::PushL(filter);

 	filter->SetEventType(KLogShortMessageEventTypeUid);//the same as the type UID of added events

 	//Filter the events

 	if(view->SetFilterL(*filter, active->iStatus))

 		{

 		active->StartL();

 		CActiveScheduler::Start();//Here the test fucntion hangs and never returns, if the defect is not fixed.

 		TEST(view->CountL() == 1);

 		}

 	//Visit the events

 	TInt j = 0;

 	TEST(view->FirstL(active->iStatus));

 	do

 		{

 		active->StartL();

 		CActiveScheduler::Start();

 		TEST2(active->iStatus.Int(), KErrNone);

 		const CLogEvent& e = view->Event();

 		TheTest.Printf(_L("View Entry[%d]: Id:%d, Type:%x\n"), j, e.Id(), e.EventType().iUid);

 		const TDesC8& data = e.Data();

 		TEST(data.Length() == KSizeOfEventData);

 		//Touch the data.

 		for(TInt k=0;k<KSizeOfEventData;++k)

 			{

 			TUint8 c = data[k];

 			TEST(c == static_cast <TUint8> (k % 256));

 			}

 		++j;

 		}

 	while(view->NextL(active->iStatus));

 	CleanupStack::PopAndDestroy(filter);

 	CleanupStack::PopAndDestroy(view);

 	CleanupStack::PopAndDestroy(event);

 	CleanupStack::PopAndDestroy(active);

 	CleanupStack::PopAndDestroy(client2);

 	CleanupStack::PopAndDestroy(client1);

 	}

 void doTestsL()

 	{

 	TestUtils::Initialize(_L("t_lognotify"));

 	TestUtils::DeleteDatabaseL();

 	TheTest.Start(_L("Notifications"));

 	TestNotificationL();

 	theLog.Write(_L8("Test 1 OK\n"));

 	TheTest.Next(_L("INC045485"));

 	::INC045485L();

 	TheTest.Next(_L("Cancelling Notifications"));

 	TestCancelNotificationL();

 	theLog.Write(_L8("Test 2 OK\n"));

 	TheTest.Next(_L("Notify with View Purge"));

 	TestViewPurgeNotifyL();

 	theLog.Write(_L8("Test 3 OK\n"));

 	TheTest.Next(_L("DEF060381"));

 	::DEF060381L();

 	}