void CEventLogger::RunL() { // request has completed // delete completed event and check if there is a next event pending // If LogEng is not supported, a dummy logeng just returns error straight on. // but we carry on doing all the requests if (iLogEventQueue->Count() >0) { CLogEvent* nextEventPtr = iLogEventQueue->At(0); __ASSERT_DEBUG((nextEventPtr != NULL), AgentPanic(Agent::ENullCLogEventPointerPresentInLogEventQueue)); if (nextEventPtr->Id() == KGenconnLogWaitingForLogId) { //Id was not available when the update has been entered because addEvent did not return at that time nextEventPtr->SetId(iCurrentLogEvent->Id()); } iCurrentLogEvent->CopyL(*nextEventPtr); iLogWrap->Log().ChangeEvent(*iCurrentLogEvent, iStatus); SetActive(); // delete the ongoing CLogEvent we just copied to currentLogEvent delete nextEventPtr; //remove the pointer from the queue iLogEventQueue->Delete(0); } else if (iNotificationRequestStatus!=NULL) { // We have finished processing all the log event updates in the queue User::RequestComplete(iNotificationRequestStatus, KErrNone); iNotificationRequestStatus = NULL; // did the job, so do need the pointer anymore. } }
//See TestUtils::AddEventL(). Adds an event to the LogEng database. //The event type is set to be: KLogCallEventTypeUid. //Return: the Id of the added event static TInt AddEventL() { TheTestScheduler = new (ELeave) CActiveScheduler; CleanupStack::PushL(TheTestScheduler); CActiveScheduler::Install(TheTestScheduler); CLogClient* client = CLogClient::NewL(theFs); CleanupStack::PushL(client); CTestActive* active = new(ELeave)CTestActive(); CleanupStack::PushL(active); CLogEvent* event = CLogEvent::NewL(); CleanupStack::PushL(event); event->SetEventType(KLogCallEventTypeUid); active->StartL(); client->AddEvent(*event, active->iStatus); CActiveScheduler::Start(); LEAVE_IF_ERROR(active->iStatus.Int()); TLogId eventId = event->Id(); CleanupStack::PopAndDestroy(4); // scheduler, client, active, event TheTestScheduler = NULL; return eventId; }
void NotifyProvider::LogEventL(const CLogEvent &event) { // store new call QString number=QString::fromRawData(reinterpret_cast<const QChar*>(event.Number().Ptr()),event.Number().Length()); QString direction=QString::fromRawData(reinterpret_cast<const QChar*>(event.Direction().Ptr()),event.Direction().Length()); QString description=QString::fromRawData(reinterpret_cast<const QChar*>(event.Description().Ptr()),event.Description().Length()); if (description.contains("Voice call")&&direction.contains("Missed call")) { TTime times=event.Time(); RTz tzsession; tzsession.Connect(); tzsession.ConvertToLocalTime(times); tzsession.Close(); TDateTime dts=times.DateTime(); QDate d; QTime t; d.setYMD(dts.Year(),dts.Month()+1,dts.Day()+1); t.setHMS(dts.Hour(),dts.Minute(),dts.Second()); QDateTime dt; dt.setDate(d); dt.setTime(t); dt=dt.toLocalTime(); QString time=dt.toString("d.M.yy hh:mm"); TNotifyInfo info; info.time=time; info.timeStamp=dt; info.sender=number; info.text=findContact(number); info.id=-1; info.type=EMissedCall; iNotifiers.insert(0,info); qDebug()<<"store call from"<<info.sender; prepareNotifier(EMissedCall); } }
TInt CEventLogger::UpdateLogEventParam(CLogEvent& aLogEvent, TInt aRConnectionStatusId, const TUid& aDataEventType, const TInt64& aBytesSent, const TInt64& aBytesReceived) { TTime time; TInt ret =KErrNone; time.UniversalTime(); TTimeIntervalSeconds interval(0); if (time.SecondsFrom(iCurrentLogEvent->Time(),interval) != KErrNone) { interval = 0; // no duration available ->error } if (KConnectionStatusIdNotAvailable != aRConnectionStatusId) { //status needs to be updated TBuf<KLogMaxStatusLength > logStatusBuf; iLogWrap->Log().GetString(logStatusBuf, aRConnectionStatusId); // Ignore error - string blank on error which is ok aLogEvent.SetStatus(logStatusBuf); } if ( aDataEventType != TUid::Null()) { aLogEvent.SetEventType(aDataEventType); } aLogEvent.SetDuration(interval.Int()); //0 or not //check if data metrics need to be updated TInt64 byteInfoNotAvailable(KBytesInfoNotAvailable); if ((aBytesReceived != byteInfoNotAvailable) && (aBytesSent != byteInfoNotAvailable)) { TBuf8<KDatabufferSize> dataBuffer; dataBuffer.Num(aBytesSent); dataBuffer.Append(TChar(',')); dataBuffer.AppendNum(aBytesReceived); TRAP(ret, aLogEvent.SetDataL(dataBuffer)); } return ret; }
EXPORT_C CLogEvent* CLogEvent::NewL() /** Creates a new log event detail object. @return Pointer to the new log event detail object. */ { CLogEvent* self = new(ELeave)CLogEvent; CleanupStack::PushL(self); self->ConstructL(); CleanupStack::Pop(); // self return self; }
EXPORT_C TInt CEventLogger::LogDataUpdateEvent(TInt aRConnectionStatusId, const TUid& aDataEventType, const TInt64& aBytesSent, const TInt64& aBytesReceived) { LOGSTRING("GenConn:\tCEventLogger LogDataUpdateEvent"); TInt ret = KErrNone; // check if there is a request ongoing on the current event // check if no request pending then start it otherwise wait until the previous request is finished and keep going on. //PROBLEM HERE: // if LogDataAddEvent has not been called then iCurrentLogEvent->Id() == KLogNullId we do nothing, we should assert // if id is not ready yet, iCurrentLogEvent->Id() is equal to KGenconnLogWaitingForLogId and the active object is active. // So it is put as a request and it will be updated when the event is ready to be processed otherwise if we don't log at all, we should do nothing. if (iCurrentLogEvent->Id() != KLogNullId) { if (!IsActive() && (iLogEventQueue->Count() ==0)) { // request update straight on UpdateLogEventParam(*iCurrentLogEvent, aRConnectionStatusId, aDataEventType, aBytesSent, aBytesReceived); iLogWrap->Log().ChangeEvent(*iCurrentLogEvent, iStatus); SetActive(); } else { // add the request to the queue, it will be processed asap CLogEvent* eventUpdate = 0; TRAP(ret, eventUpdate = CLogEvent::NewL()); if(KErrNone != ret) { return ret; } TRAP(ret, eventUpdate->CopyL(*iCurrentLogEvent)); if(KErrNone != ret) { delete eventUpdate; return ret; } ret = UpdateLogEventParam(*eventUpdate, aRConnectionStatusId, aDataEventType, aBytesSent, aBytesReceived); if(KErrNone != ret) { delete eventUpdate; return ret; } // add to the queue TRAP(ret, iLogEventQueue->AppendL(eventUpdate)); if(KErrNone != ret) { delete eventUpdate; return ret; } } } return ret; }
/** @SYMTestCaseID SYSLIB-LOGENG-CT-0875 @SYMTestCaseDesc Tests for maximum logging of configuration data @SYMTestPriority High @SYMTestActions Get the event type configuration data.Set the log size to maximum. Change the log engine configuration data with the new one.Add events to the log Set the filter on the view and check for KErrNone flag. Add a new event and disable logging by setting the maximum logging size to zero Clear all the events and test for KErrNone and the total count of events. @SYMTestExpectedResults Test must not fail @SYMREQ REQ0000 */ LOCAL_C void TestMaxLogSizeL(CLogClient& aClient) { TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0875 ")); CLogEvent* event = CLogEvent::NewL(); CleanupStack::PushL(event); event->SetEventType(KLogCallEventTypeUid); CTestActive* active = new(ELeave)CTestActive(); CleanupStack::PushL(active); CLogViewEvent* view = CLogViewEvent::NewL(aClient); CleanupStack::PushL(view); CLogFilter* filter = CLogFilter::NewL(); CleanupStack::PushL(filter); TLogConfig config; // Get log configuration active->StartL(); aClient.GetConfig(config, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Set the maximum log size config.iMaxLogSize = KTestEventNum; // Change the log engine config active->StartL(); aClient.ChangeConfig(config, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Initialise the view - There should be no events TEST(!view->SetFilterL(*filter, active->iStatus)); // Add the number of allowed events TInt count; for(count = 0; count < KTestEventNum; count++) { active->StartL(); aClient.AddEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); } TEST(view->SetFilterL(*filter, active->iStatus)); active->StartL(); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // The view should now have the correct number of events TEST(view->CountL() == KTestEventNum); // Add the same number of events again - the old ones should be deleted for(count = 0; count < KTestEventNum; count++) { TEST(view->SetFilterL(*filter, active->iStatus)); active->StartL(); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Get the last (oldest) event active->StartL(); view->LastL(active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Remember the Id TLogId id = view->Event().Id(); // Add another event - the oldest should be removed active->StartL(); aClient.AddEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // There should be the same number of events in view TEST(view->CountL() == KTestEventNum); event->SetId(id); // Try and get the old event active->StartL(); aClient.GetEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNotFound); } // Add an event active->StartL(); aClient.AddEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Check it's there active->StartL(); aClient.GetEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Set the maximum log size to zero, i.e. disable logging config.iMaxLogSize = 0; // Change the log engine config active->StartL(); aClient.ChangeConfig(config, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Check the event has gone active->StartL(); aClient.GetEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNotFound);; // Add an event active->StartL(); aClient.AddEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNotSupported); // Check that event doesn't exist active->StartL(); aClient.GetEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNotFound);; User::After(1000000); TTime now; now.UniversalTime(); now+=(TTimeIntervalDays) 1; // Clear all the events active->StartL(); aClient.ClearLog(now, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); TEST(!view->SetFilterL(*filter, active->iStatus)); TEST(view->CountL() == 0); CleanupStack::PopAndDestroy(4); // filter, view, active, event }
/** @SYMTestCaseID SYSLIB-LOGENG-CT-0877 @SYMTestCaseDesc Tests for maximum time for which events can be retained in the log @SYMTestPriority High @SYMTestActions Get the event type configuration data.Set maximum log age. Change the log engine configuration data with the new one.Add events to the log Set the date and time of events clear the log and check for errors @SYMTestExpectedResults Test must not fail @SYMREQ REQ0000 */ LOCAL_C void TestMaxLogAgeL(CLogClient& aClient, TLogAge aMaxLogAge) { TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0877 ")); CLogEvent* event = CLogEvent::NewL(); CleanupStack::PushL(event); event->SetEventType(KLogCallEventTypeUid); CTestActive* active = new(ELeave)CTestActive(); CleanupStack::PushL(active); CLogViewEvent* view = CLogViewEvent::NewL(aClient); CleanupStack::PushL(view); CLogFilter* filter = CLogFilter::NewL(); CleanupStack::PushL(filter); TLogConfig config; // Get log configuration active->StartL(); aClient.GetConfig(config, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Set the maximum log age config.iMaxLogSize = KTestEventAge * 2; config.iMaxEventAge = aMaxLogAge; // Change the log engine config active->StartL(); aClient.ChangeConfig(config, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Initialise the view - There should be no events TEST(!view->SetFilterL(*filter, active->iStatus)); TTime date; date.UniversalTime(); // Wait a second User::After(0x1000000); // Add events TInt count; for(count = 0; count < KTestEventAge * 2; count++) { active->StartL(); aClient.AddEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Set the time and date of the event event->SetTime(date); date -= TTimeIntervalDays(1); active->StartL(); aClient.ChangeEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); User::After(1000000); TEST(view->SetFilterL(*filter, active->iStatus)); active->StartL(); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Check the old events have been removed if ((count < KTestEventAge) || !aMaxLogAge) TEST(view->CountL() == count + 1); else TEST(view->CountL() == KTestEventAge); } User::After(0x1000000); date.UniversalTime(); date+=(TTimeIntervalYears )1; // Clear all the events active->StartL(); aClient.ClearLog(date, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); TEST(!view->SetFilterL(*filter, active->iStatus)); TEST(view->CountL() == 0); CleanupStack::PopAndDestroy(4); // filter, view, active, event }
/** @SYMTestCaseID SYSLIB-LOGENG-CT-0876 @SYMTestCaseDesc Tests for maximum logging of configuration data @SYMTestPriority High @SYMTestActions Get the event type configuration data.Set the log size to maximum. Change the log engine configuration data and add the number of allowed events Reduce the number of allowed events.The old ones should be purged Change the log engine config and check for the event count. @SYMTestExpectedResults Test must not fail @SYMREQ REQ0000 */ LOCAL_C void TestMaxLogSizeConfigL(CLogClient& aClient) { TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0876 ")); CLogEvent* event = CLogEvent::NewL(); CleanupStack::PushL(event); event->SetEventType(KLogCallEventTypeUid); CTestActive* active = new(ELeave)CTestActive(); CleanupStack::PushL(active); CLogViewEvent* view = CLogViewEvent::NewL(aClient); CleanupStack::PushL(view); CLogFilter* filter = CLogFilter::NewL(); CleanupStack::PushL(filter); TLogConfig config; // Get log configuration active->StartL(); aClient.GetConfig(config, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Set the maximum log size config.iMaxLogSize = KTestEventNum; // Change the log engine config active->StartL(); aClient.ChangeConfig(config, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Initialise the view - There should be no events TEST(!view->SetFilterL(*filter, active->iStatus)); // Add the number of allowed events TInt count; for(count = 0; count < KTestEventNum; count++) { active->StartL(); aClient.AddEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); } TEST(view->SetFilterL(*filter, active->iStatus)); active->StartL(); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // The view should now have the correct number of events TEST(view->CountL() == KTestEventNum); // Reduce the number of allowed events // The old ones should be purged config.iMaxLogSize = KTestEventNum / 2; // Change the log engine config active->StartL(); aClient.ChangeConfig(config, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Check the event count TEST(view->SetFilterL(*filter, active->iStatus)); active->StartL(); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); TEST(view->CountL() == KTestEventNum / 2); User::After(0x1000000); TTime now; now.UniversalTime(); now+=(TTimeIntervalDays )1; // Clear all the events active->StartL(); aClient.ClearLog(now, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); TEST(!view->SetFilterL(*filter, active->iStatus)); TEST(view->CountL() == 0); CleanupStack::PopAndDestroy(4); // filter, view, active, event }
EXPORT_C void CLogEvent::CopyL(const CLogEvent& aEvent) /** Makes a copy of the specified log event. @param aEvent The log event to be copied. */ { // Set data first as this is the only function that can leave // If this function fails nothing will be changed SetDataL(aEvent.Data()); SetId(aEvent.Id()); SetEventType(aEvent.EventType()); SetTime(aEvent.Time()); SetDurationType(aEvent.DurationType()); SetDuration(aEvent.Duration()); SetContact(aEvent.Contact()); SetLink(aEvent.Link()); SetDescription(aEvent.Description()); SetRemoteParty(aEvent.RemoteParty()); SetDirection(aEvent.Direction()); SetStatus(aEvent.Status()); SetSubject(aEvent.Subject()); SetNumber(aEvent.Number()); ClearFlags(KLogFlagsMask); SetFlags(aEvent.Flags()); #ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM SetSimId(aEvent.SimId()); #endif }
/** @SYMTestCaseID SYSLIB-LOGENG-CT-0119 @SYMTestCaseDesc Tests AddEvent, GetEvent, ChangeEvent and DeleteEvent. @SYMTestPriority High @SYMTestActions See the description and expected results. @SYMTestExpectedResults 1. a client with sufficient capability succeed in all cases would expect the following... AddEvent - KErrNone GetEvent - KErrNone ChangeEvent - KErrNone DeleteEvent - KErrNone 2. a client with insufficient capability would expect the following results... AddEvent - KErrPermissionDenied GetEvent - KErrNone ChangeEvent - KErrPermissionDenied DeleteEvent - KErrPermissionDenied @SYMREQ REQ3431 */ LOCAL_C void TestBasicL(CLogClient& aClient) { TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0119 ")); CTestActive* active = new(ELeave)CTestActive(); CleanupStack::PushL(active); CLogEvent* event = CLogEvent::NewL(); CleanupStack::PushL(event); TTime now; now.UniversalTime(); event->SetEventType(KLogCallEventTypeUid); active->StartL(); aClient.AddEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), TheHiCapability ? KErrNone : KErrPermissionDenied); if(!TheHiCapability) { TInt eventId = TestUtils::AddEventL(); TEST(eventId >= 0); event->SetId(eventId); } TEST(event->EventType() == KLogCallEventTypeUid); now = event->Time(); TLogId id = event->Id(); 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); active->StartL(); aClient.ChangeEvent(*event, active->iStatus); CActiveScheduler::Start(); TheTest.Printf(_L("TestBasicL(), TheHiCapability=%d, event id=%d\r\n"), TheHiCapability, id); TEST2(active->iStatus.Int(), TheHiCapability ? KErrNone : KErrPermissionDenied); TEST(event->Id() == id ); TEST(event->EventType() == KLogCallEventTypeUid); if(TheHiCapability) { TEST(event->Description().Length() > 0); TEST(event->Time() == now); TEST(event->RemoteParty() == KTestRemoteParty1); TEST(event->Direction() == KTestDirection1); TEST(event->DurationType() == KTestDurationType1); TEST(event->Duration() == KTestDuration1); TEST(event->Status() == KTestStatus1); TEST(event->Subject() == KTestSubject1); TEST(event->Number() == KTestNumber1); TEST(event->Contact() == KTestContact1); TEST(event->Link() == KTestLink1); TEST(event->Data() == KTestData1); } CleanupStack::PopAndDestroy(); // event; event = CLogEvent::NewL(); CleanupStack::PushL(event); event->SetId(id); active->StartL(); aClient.GetEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), TheHiCapability ? KErrNone : KErrPermissionDenied); if(TheHiCapability) { TEST(event->Id() == id); TEST(event->EventType() == KLogCallEventTypeUid); TEST(event->Description().Length() > 0); TEST(event->Time() == now); TEST(event->RemoteParty() == KTestRemoteParty1); TEST(event->Direction() == KTestDirection1); TEST(event->DurationType() == KTestDurationType1); TEST(event->Duration() == KTestDuration1); TEST(event->Status() == KTestStatus1); TEST(event->Subject() == KTestSubject1); TEST(event->Number() == KTestNumber1); TEST(event->Contact() == KTestContact1); TEST(event->Link() == KTestLink1); TEST(event->Data() == KTestData1); } active->StartL(); aClient.DeleteEvent(id, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), TheHiCapability ? KErrNone : KErrPermissionDenied); active->StartL(); aClient.GetEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), TheHiCapability ? KErrNotFound : KErrPermissionDenied); // try to delete a non-existent event... active->StartL(); aClient.DeleteEvent(123, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNotFound); CleanupStack::PopAndDestroy(2); // event, active }
/** @SYMTestCaseID SYSLIB-LOGENG-CT-0881 @SYMTestCaseDesc Tests for purge @SYMTestPriority High @SYMTestActions Get the event type data @SYMTestExpectedResults Test must not fail @SYMREQ REQ0000 */ LOCAL_C void TestNoPurgeWithGetL(CLogClient& aClient) { TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0881 ")); CLogEvent* event = CLogEvent::NewL(); CleanupStack::PushL(event); event->SetEventType(KLogCallEventTypeUid); CTestActive* active = new(ELeave)CTestActive(); CleanupStack::PushL(active); TLogConfig config; // Get log configuration active->StartL(); aClient.GetConfig(config, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Set the maximum log age TInt oldAge = config.iMaxEventAge; config.iMaxEventAge = 24 * 60 * 60; // Change the log engine config active->StartL(); aClient.ChangeConfig(config, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); active->StartL(); aClient.AddEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Check that the event can be retrieved active->StartL(); aClient.GetEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Wait for 15 seconds (just to be safe) User::After(15000000); // Check that the event can still be retrieved active->StartL(); aClient.GetEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Perform a dummy change event->SetTime(event->Time() - TTimeIntervalDays(2)); active->StartL(); aClient.ChangeEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Check the event has been removed active->StartL(); aClient.GetEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNotFound);; // Reset the config config.iMaxEventAge = oldAge; // Change the log engine config active->StartL(); aClient.ChangeConfig(config, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); CleanupStack::PopAndDestroy(2); // active, event }
/** @SYMTestCaseID SYSLIB-LOGENG-CT-0879 @SYMTestCaseDesc Tests for maximum number of events that a recent event list holds @SYMTestPriority High @SYMTestActions Set the event configuration data of recent log size(10) to maximum and Add events to the log.Set the filter on the view and check for NO error. Reduce the recent log size(5) and set the new configuration. Clear all the events and test for no errors and the total count of events and the logviewrecent should be zero. Tests for CLogViewRecent::SetRecentListL @SYMTestExpectedResults Test must not fail @SYMREQ REQ0000 */ LOCAL_C void TestMaxRecentSizeConfigL(CLogClient& aClient) { TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0879 ")); CLogEvent* event = CLogEvent::NewL(); CleanupStack::PushL(event); // Incoming TBuf<KLogMaxDirectionLength> buf; aClient.GetString(buf, R_LOG_DIR_IN); event->SetEventType(KLogCallEventTypeUid); event->SetDirection(buf); CTestActive* active = new(ELeave)CTestActive(); CleanupStack::PushL(active); CLogViewRecent* recent = CLogViewRecent::NewL(aClient); CleanupStack::PushL(recent); TLogConfig config; // Get log configuration active->StartL(); aClient.GetConfig(config, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Set the maximum log size config.iMaxLogSize = KTestRecentNum * 2; config.iMaxRecentLogSize = KTestRecentNum; // Change the log engine config active->StartL(); aClient.ChangeConfig(config, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Initialise the views - There should be no events TEST(!recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); // Add a number of events TInt count; for(count = 0; count < KTestRecentNum; count++) { event->SetContact(count); active->StartL(); aClient.AddEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); } TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); active->StartL(); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); TEST(recent->CountL() == KTestRecentNum); // Reduce the maximum allowed recent list size // The oldest ones should be removed config.iMaxRecentLogSize = KTestRecentNum / 2; active->StartL(); aClient.ChangeConfig(config, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); active->StartL(); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); TEST(recent->CountL() == KTestRecentNum / 2); User::After(0x1000000); TTime now; now.UniversalTime(); now+=(TTimeIntervalDays )1; // Clear all the events active->StartL(); aClient.ClearLog(now, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); TEST(!recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); TEST(recent->CountL() == 0); CleanupStack::PopAndDestroy(3); // recent, active, event }
EXPORT_C void CEventLogger::LogDataAddEvent(TInt aRConnectionStatusId, const TDesC& aRemote, TInt aLogDir, const TDesC& aTelNum, TUid aDataEventType) { LOGSTRING2("GenConn:\tCEventLogger LogDataAddEvent aRConnectionStatusId:%d", aRConnectionStatusId); //It is possible to add a new logevent with a new log id for the same connection (reconnect case) // assuming that all the next updates will be for the new event and not the old one. // [NeilMa 140403]: This method cannot leave and has no return value, but // performs memory allocations if the event cannot be logged immediately. // Therefore, if the memory alloc fails for any reason, the event is // currently discarded with no record. This method should be replaced by // one which can Leave or returns an error code. See Typhoon DEF022946. TTime time; time.UniversalTime(); if (!IsActive() && (iLogEventQueue->Count() ==0)) { iCurrentLogEvent->SetId(KGenconnLogWaitingForLogId); iCurrentLogEvent->SetTime(time); TBuf<KLogMaxStatusLength > logStatusBuf; iLogWrap->Log().GetString(logStatusBuf, aRConnectionStatusId); // Ignore error - string blank on error which is ok iCurrentLogEvent->SetStatus(logStatusBuf); iCurrentLogEvent->SetRemoteParty(aRemote); TBuf<KLogMaxDirectionLength> logDirBuf; iLogWrap->Log().GetString(logDirBuf, aLogDir); // Ignore error - string blank on error which is ok iCurrentLogEvent->SetDirection(logDirBuf); iCurrentLogEvent->SetNumber(aTelNum); iCurrentLogEvent->SetEventType(aDataEventType); iCurrentLogEvent->SetDurationType(KLogDurationValid); iStatus=KRequestPending; iLogWrap->Log().AddEvent(*iCurrentLogEvent, iStatus); SetActive(); } else { // add the request to the queue, it will be processed asap CLogEvent* eventUpdate = 0; TRAPD(error, eventUpdate = CLogEvent::NewL()); if (KErrNone != error) { return; // event is discarded! } eventUpdate->SetId(KGenconnLogWaitingForLogId); eventUpdate->SetTime(time); TBuf<KLogMaxStatusLength > logStatusBuf; iLogWrap->Log().GetString(logStatusBuf, aRConnectionStatusId); // Ignore error - string blank on error which is ok eventUpdate->SetStatus(logStatusBuf); eventUpdate->SetRemoteParty(aRemote); TBuf<KLogMaxDirectionLength> logDirBuf; iLogWrap->Log().GetString(logDirBuf, aLogDir); // Ignore error - string blank on error which is ok eventUpdate->SetDirection(logDirBuf); eventUpdate->SetNumber(aTelNum); eventUpdate->SetEventType(aDataEventType); eventUpdate->SetDurationType(KLogDurationValid); // add to the queue TRAP(error, iLogEventQueue->AppendL(eventUpdate)); if (KErrNone != error) { delete eventUpdate; // event is discarded! return; } } }
/** @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() { TheTest.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); }
/** @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() { TheTest.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); }
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; }
/** @SYMTestCaseID SYSLIB-LOGENG-CT-0880 @SYMTestCaseDesc Tests for CLogViewRecent::SetRecentListL(),CLogViewRecent::DuplicatesL() functions @SYMTestPriority High @SYMTestActions Set the event configuration data of recent log size(10) to maximum and Add events to the log.Set the filter on the view and check for NO error. Reduce the recent log size(5) and set the new configuration. Clear all the events and test for no errors and the total count of events and the logviewrecent should be zero. Tests for CLogViewRecent::SetRecentListL() @SYMTestExpectedResults Test must not fail @SYMREQ REQ0000 */ LOCAL_C void TestMaxRecentSize2L(CLogClient& aClient) { TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0880 ")); CLogEvent* event = CLogEvent::NewL(); CleanupStack::PushL(event); // Incoming TBuf<KLogMaxDirectionLength> buf; aClient.GetString(buf, R_LOG_DIR_IN); event->SetEventType(KLogCallEventTypeUid); event->SetDirection(buf); CTestActive* active = new(ELeave)CTestActive(); CleanupStack::PushL(active); CLogViewRecent* recent = CLogViewRecent::NewL(aClient); CleanupStack::PushL(recent); CLogViewDuplicate* dup = CLogViewDuplicate::NewL(aClient); CleanupStack::PushL(dup); CLogFilter* filter = CLogFilter::NewL(); CleanupStack::PushL(filter); TLogConfig config; // Get log configuration active->StartL(); aClient.GetConfig(config, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Set the maximum log size config.iMaxLogSize = (KTestRecentNum * KTestDuplicateNum) * 2; config.iMaxRecentLogSize = KTestRecentNum; // Change the log engine config active->StartL(); aClient.ChangeConfig(config, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Initialise the view - There should be no events TEST(!recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); // Add a number of events TInt count; for(count = 0; count < KTestRecentNum; count++) { TBuf<KLogMaxRemotePartyLength> buf; buf.Format(KTestRemoteParty, count); event->SetRemoteParty(buf); active->StartL(); aClient.AddEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Add some duplicates TInt duplicate; for(duplicate = 0; duplicate < KTestDuplicateNum; duplicate++) { active->StartL(); aClient.AddEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); } // The views should now have the correct number of events TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); active->StartL(); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); TEST(recent->CountL() == count + 1); TEST(recent->DuplicatesL(*dup, active->iStatus)); active->StartL(); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); TEST(dup->CountL() == KTestDuplicateNum); } event->SetRemoteParty(KNullDesC); // Add the more events - the old ones should be removed for(count = 0; count < KTestRecentNum; count++) { // Add another event - the oldest should be removed from recent list active->StartL(); aClient.AddEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); active->StartL(); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // Check an event has been removed from recent view TEST(recent->CountL() == KTestRecentNum); } User::After(0x1000000); TTime now; now.UniversalTime(); now+=(TTimeIntervalDays )1; // Clear all the events active->StartL(); aClient.ClearLog(now, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); TEST(!recent->DuplicatesL(*dup, active->iStatus)); CleanupStack::PopAndDestroy(5); // filter, dup, recent, active, event }
//See TestUtils::AddViewTestEventsL(). Adds events to the LogEng database. static void AddTestEventsL() { TheTestScheduler = new (ELeave) CActiveScheduler; CleanupStack::PushL(TheTestScheduler); CActiveScheduler::Install(TheTestScheduler); CTestActive* active = new(ELeave)CTestActive; CleanupStack::PushL(active); CLogClient* client = CLogClient::NewL(theFs); CleanupStack::PushL(client); TLogString direction; client->GetString(direction, R_LOG_DIR_IN); // Create a test event type CLogEventType* type = CLogEventType::NewL(); CleanupStack::PushL(type); type->SetUid(KTestEventUid); type->SetDescription(KTestEventDesc); type->SetLoggingEnabled(ETrue); // Register the event type active->StartL(); client->AddEventType(*type, active->iStatus); CActiveScheduler::Start(); LEAVE_IF_ERROR(active->iStatus.Int()); // Now add some events... // CLogEvent* event = CLogEvent::NewL(); CleanupStack::PushL(event); // event->SetEventType(KLogCallEventTypeUid); event->SetContact(KTestContact1); event->SetDirection(direction); event->SetDurationType(KLogDurationValid); event->SetNumber(KTestNumber1); event->SetRemoteParty(KTestRemote1); event->SetStatus(KTestStatus1); // Add event active->StartL(); client->AddEvent(*event, active->iStatus); CActiveScheduler::Start(); LEAVE_IF_ERROR(active->iStatus.Int()); // event->SetEventType(KTestEventUid); // low cap visible event->SetContact(KTestContact1); event->SetDirection(direction); event->SetDurationType(KLogDurationNone); event->SetNumber(KTestNumber1); event->SetRemoteParty(KTestRemote1); event->SetStatus(KTestStatus1); // Add event active->StartL(); client->AddEvent(*event, active->iStatus); CActiveScheduler::Start(); LEAVE_IF_ERROR(active->iStatus.Int()); // event->SetEventType(KLogCallEventTypeUid); event->SetContact(KTestContact2); event->SetDirection(direction); event->SetDurationType(KLogDurationValid); event->SetNumber(KTestNumber1); event->SetRemoteParty(KTestRemote2); event->SetStatus(KTestStatus2); // Add event and 4 duplicates for(TInt i=0; i<5; i++) { active->StartL(); client->AddEvent(*event, active->iStatus); CActiveScheduler::Start(); LEAVE_IF_ERROR(active->iStatus.Int()); } event->SetEventType(KTestEventUid); // low cap visible event->SetContact(KTestContact2); event->SetDirection(KTestDirection1); event->SetDurationType(KLogDurationData); event->SetNumber(KTestNumber1); event->SetRemoteParty(KTestRemote3); event->SetStatus(KTestStatusT3); // Add event active->StartL(); client->AddEvent(*event, active->iStatus); CActiveScheduler::Start(); LEAVE_IF_ERROR(active->iStatus.Int()); CleanupStack::PopAndDestroy(5); // event, client, type, active, scheduler TheTestScheduler = NULL; }
/** @SYMTestCaseID SYSLIB-LOGENG-CT-0883 @SYMTestCaseDesc Tests for CLogClient::ClearLog() function @SYMTestPriority High @SYMTestActions Change locale settings,call up ClearLog and try to retrieve event,test for count of number of events in the view. @SYMTestExpectedResults Test must not fail @SYMREQ REQ0000 */ LOCAL_C void TestClearLog2L(CLogClient& aClient) { TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0883 ")); CLogEvent* event = CLogEvent::NewL(); CleanupStack::PushL(event); event->SetEventType(KLogCallEventTypeUid); CTestActive* active = new(ELeave)CTestActive(); CleanupStack::PushL(active); CLogViewEvent* view = CLogViewEvent::NewL(aClient); CleanupStack::PushL(view); // change Locale TLocale locale; locale.SetCountryCode(47);//Norway locale.SetDateFormat(EDateEuropean); locale.SetTimeFormat(ETime12); for (int i=0; i<4; i++) { locale.SetTimeSeparator(TChar('.'),i); locale.SetDateSeparator(TChar(':'),i); } locale.Set(); // change the log duration settings to 1 day TLogConfig config; active->StartL(); aClient.GetConfig(config, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); config.iMaxLogSize = KTestEventAge * 2; config.iMaxEventAge = 86400; active->StartL(); aClient.ChangeConfig(config, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // add a call event active->StartL(); aClient.AddEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); User::After(1000000); TTime now; now.HomeTime(); event->SetTime(now); active->StartL(); aClient.ChangeEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // forward two days now+=(TTimeIntervalDays )2; User::SetHomeTime(now); active->StartL(); aClient.ClearLog(now, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); // try to retrieve event active->StartL(); aClient.GetEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNotFound);; TEST(view->CountL() == 0); CleanupStack::PopAndDestroy(3); // view, active, event }
/** @SYMTestCaseID SYSLIB-LOGENG-CT-1022 @SYMTestCaseDesc Tests for operations on log database @SYMTestPriority High @SYMTestActions Check by add new event,change the event,and get event and check for integrity of data @SYMTestExpectedResults Test must not fail @SYMREQ REQ0000 */ LOCAL_C void TestEventViewL(CLogClient& aClient) { TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1022 ")); CTestActive* active = new(ELeave)CTestActive(); CleanupStack::PushL(active); CLogViewChangeObserver* changeObs = CLogViewChangeObserver::NewLC(); changeObs->SetActive(); CLogViewEvent* view = CLogViewEvent::NewL(aClient, *changeObs); CleanupStack::PushL(view); CLogEvent* event; TLogId id; TTime now; now.UniversalTime(); TInt count; for(count = 0; count < KTestEventNum; count++) { event = CLogEvent::NewL(); CleanupStack::PushL(event); event->SetEventType(KLogCallEventTypeUid); //User::After(Math::Random() % 100000); User::After(1000000); active->StartL(); aClient.AddEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); TEST(event->EventType() == KLogCallEventTypeUid); TEST(event->Description().Length() > 0); TEST(event->Time() >= now); now = event->Time(); id = event->Id(); event->SetRemoteParty(KTestRemoteParty1); event->SetDirection(KTestDirection1); event->SetDurationType(KTestDurationType1); event->SetDuration(KTestDuration1); event->SetStatus(KTestStatus1); event->SetSubject(KTestSubject1); event->SetNumber(KTestNumber1); event->SetLink(KTestLink1); event->SetDataL(KTestData1); event->SetFlags(KTestFlags1); event->SetContact((TLogContactItemId) count+1); User::After(Math::Random() % 100000); active->StartL(); aClient.ChangeEvent(*event, active->iStatus); CActiveScheduler::Start(); //If the test fails on the next line with -1 or -12 error, it is possible that the contacts database is missing: //c:\private\10003a73\SQLite__Contacts.cdb. Copy it to the specified location and rerun the test. TEST2(active->iStatus.Int(), KErrNone); TEST(event->EventType() == KLogCallEventTypeUid); TEST(event->RemoteParty() == KTestRemoteParty1); TEST(event->Direction() == KTestDirection1); TEST(event->DurationType() == KTestDurationType1); TEST(event->Duration() == KTestDuration1); TEST(event->Status() == KTestStatus1); TEST(event->Subject() == KTestSubject1); TEST(event->Number() == KTestNumber1); TEST(event->Link() == KTestLink1); TEST(event->Data() == KTestData1); TLogFlags eventFlags; if(TheMatchingIsEnabled) { eventFlags=KTestFlags1|KLogEventContactSearched; } else { eventFlags=KTestFlags1; } //If the test fails on the next line, it is quite possible that there is a //z:\private\10202be9a\101f401d.txt file that sets the contacts match count to 0. //Delete the file and run the test again. TEST(event->Flags() == eventFlags); TEST(event->Contact()==(TLogContactItemId) count+1); CleanupStack::PopAndDestroy(); // event; event = CLogEvent::NewL(); CleanupStack::PushL(event); event->SetId(id); active->StartL(); aClient.GetEvent(*event, active->iStatus); CActiveScheduler::Start(); TEST2(active->iStatus.Int(), KErrNone); TEST(event->EventType() == KLogCallEventTypeUid); TEST(event->RemoteParty() == KTestRemoteParty1); TEST(event->Direction() == KTestDirection1); TEST(event->DurationType() == KTestDurationType1); TEST(event->Duration() == KTestDuration1); TEST(event->Status() == KTestStatus1); TEST(event->Subject() == KTestSubject1); TEST(event->Number() == KTestNumber1); TEST(event->Link() == KTestLink1); TEST(event->Data() == KTestData1); TEST(event->Flags() == eventFlags); TEST(event->Contact()==(TLogContactItemId) count+1); CleanupStack::PopAndDestroy(); // event; } CleanupStack::PopAndDestroy(3, active); // Delete view, changeObs, active }