1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 #include "ut_logsreader.h"

    18 #include "logsreader.h"

    19 #include "logsevent.h"

    20 #include <logcli.h>

    21 

    22 #include <QtTest/QtTest>

    23 

    24 void UT_LogsReader::initTestCase()

    25 {

    26     QT_TRAP_THROWING( mLogClient = CLogClient::NewL(mFs); )

    27 }

    28 

    29 void UT_LogsReader::cleanupTestCase()

    30 {

    31     delete mLogClient;

    32 }

    33 

    34 

    35 void UT_LogsReader::init()

    36 {

    37     mErrorOccurred = false;

    38     mError = 0;

    39     mReader = new LogsReader(mFs, *mLogClient, mStrings, mEvents, *this );

    40 }

    41 

    42 void UT_LogsReader::cleanup()

    43 {

    44     delete mReader;

    45     while (!mEvents.isEmpty()){

    46         delete mEvents.takeFirst();

    47     }

    48     

    49 }

    50 

    51 void UT_LogsReader::testConstructor()

    52 {

    53     QVERIFY( mReader );

    54     QVERIFY( mReader->mReadStates.count() > 0 );

    55     QVERIFY( mReader->mModifyingStates.count() == 0 );

    56     QVERIFY( mReader->mCurrentStateMachine == &mReader->mReadStates );

    57 }

    58 

    59 

    60 void UT_LogsReader::testStart()

    61 {

    62     QVERIFY( !mReader->mLogViewRecent );

    63     QVERIFY( !mReader->mDuplicatesView );

    64     QVERIFY( mReader->start() == 0 );

    65     QVERIFY( mReader->IsActive() );

    66     QVERIFY( mReader->mLogViewRecent );

    67     QVERIFY( mReader->mDuplicatesView );

    68     QVERIFY( mReader->mCurrentStateMachine == &mReader->mReadStates );

    69     QVERIFY( mReader->isRecentView() );

    70     

    71     // Starting second time should go ok

    72     QVERIFY( mReader->start() == 0 );

    73     QVERIFY( mReader->IsActive() );

    74     QVERIFY( mReader->mLogViewRecent );

    75     

    76     // Starting when deleting is in progress should fail

    77     mReader->mCurrentStateMachine = &mReader->mModifyingStates;

    78     QVERIFY( mReader->start() == KErrInUse ); 

    79 }

    80 

    81 void UT_LogsReader::testStart2()

    82 {

    83     qDeleteAll( mReader->mReadStates );

    84     mReader->mReadStates.clear();

    85     mReader->mReadAllEvents = true;

    86     

    87     QVERIFY( !mReader->mLogViewEvent );

    88     QVERIFY( !mReader->mDuplicatesView );

    89     QVERIFY( mReader->start() == 0 );

    90     QVERIFY( mReader->IsActive() );

    91     QVERIFY( mReader->mLogViewEvent );

    92     QVERIFY( mReader->mDuplicatesView );

    93     QVERIFY( mReader->mCurrentStateMachine == &mReader->mReadStates );

    94     QVERIFY( !mReader->isRecentView() );

    95     

    96     // Starting second time should go ok

    97     QVERIFY( mReader->start() == 0 );

    98     QVERIFY( mReader->IsActive() );

    99     QVERIFY( mReader->mLogViewEvent );

   100 }

   101 

   102 void UT_LogsReader::testStop()

   103 {

   104     mReader->stop();

   105     QVERIFY( mReader->start() == 0 );

   106     QVERIFY( mReader->IsActive() );

   107     mReader->stop();

   108     QVERIFY( !mReader->IsActive() );

   109     QVERIFY( !mReader->mLogViewEvent );

   110     QVERIFY( !mReader->mDuplicatesView );

   111 }

   112 

   113 void UT_LogsReader::testMarkEventSeen()

   114 {

   115     QVERIFY( !mReader->mLogViewRecent );

   116     QVERIFY( !mReader->mDuplicatesView );

   117     QVERIFY( mReader->markEventSeen(1) == 0 );

   118     QVERIFY( mReader->IsActive() );

   119     QVERIFY( mReader->mLogViewRecent );

   120     QVERIFY( mReader->mDuplicatesView );

   121     QVERIFY( mReader->mCurrentStateMachine == &mReader->mModifyingStates );

   122     QVERIFY( mReader->mModifyingStates.count() > 0 );

   123     

   124     //starting second time should fail

   125     QVERIFY( mReader->markEventSeen(1) == KErrInUse );

   126     

   127     //starting when reading is in progress should be ok

   128     mReader->mCurrentStateMachine = &mReader->mReadStates;

   129     QVERIFY( mReader->markEventSeen(1) == 0 );

   130 }

   131 

   132 void UT_LogsReader::testReadDuplicates()

   133 {

   134     QVERIFY( !mReader->mLogViewRecent );

   135     QVERIFY( !mReader->mDuplicatesView );

   136     QVERIFY( mReader->readDuplicates(1) == 0 );

   137     QVERIFY( mReader->IsActive() );

   138     QVERIFY( mReader->mLogViewRecent );

   139     QVERIFY( mReader->mDuplicatesView );

   140     QVERIFY( mReader->mCurrentStateMachine == &mReader->mDuplicateReadingStates );

   141     QVERIFY( mReader->mDuplicateReadingStates.count() > 0 );

   142     

   143     //starting second time is ok

   144     QVERIFY( mReader->readDuplicates(1) == 0 );

   145     

   146     //starting when reading is in progress is not allowed

   147     mReader->mCurrentStateMachine = &mReader->mReadStates;

   148     QVERIFY( mReader->readDuplicates(1) != 0 );

   149 }

   150 

   151 void UT_LogsReader::testRunL()

   152 {

   153     mReader->start();

   154     

   155     // Test ok scenario

   156     mReader->Cancel();

   157     mReader->iStatus = KErrNone;

   158     mReader->RunL();

   159     QVERIFY( !mErrorOccurred );

   160     QVERIFY( mError == 0 );

   161     QVERIFY( mReader->IsActive() );

   162 

   163     // Test failure

   164     mReader->Cancel();

   165     mReader->iStatus = KErrNotFound;

   166     TRAPD( err, mReader->RunL() );

   167     QVERIFY( err == KErrNotFound );

   168     

   169 }

   170 

   171 void UT_LogsReader::testRunError()

   172 {

   173     // No fatal callback for access denied or in use errors

   174     TInt err = KErrAccessDenied;

   175     QVERIFY( mReader->RunError(err) == KErrNone );

   176     QVERIFY( !mErrorOccurred );

   177     QVERIFY( mError == KErrAccessDenied );

   178     

   179     err = KErrInUse;

   180     QVERIFY( mReader->RunError(err) == KErrNone );

   181     QVERIFY( !mErrorOccurred );

   182     QVERIFY( mError == KErrInUse );

   183     

   184     err = KErrNotFound;

   185     QVERIFY( mReader->RunError(err) == KErrNone );

   186     QVERIFY( mErrorOccurred );

   187     QVERIFY( mError == KErrNotFound );

   188 }

   189 

   190 void UT_LogsReader::testStateContext()

   191 {

   192     mReader->mCurrentStateIndex = 0;

   193     QVERIFY( mReader->mCurrentStateMachine == &mReader->mReadStates );

   194     mReader->setCurrentState(*mReader->mReadStates[1]);

   195     QVERIFY( mReader->mCurrentStateIndex == 1 );

   196     

   197     //wrong state machine is set as current, state isn't changed

   198     LogsReaderStateBase* unknownState = new LogsReaderStateBase( *mReader );

   199     mReader->mModifyingStates.append(unknownState);

   200     QVERIFY( mReader->mCurrentStateMachine == &mReader->mReadStates );

   201     mReader->setCurrentState(*mReader->mModifyingStates[0]);

   202     QVERIFY( mReader->mCurrentStateIndex == 1 );

   203 

   204     //once again with the correct state machine, state changed

   205     mReader->mCurrentStateMachine = &mReader->mModifyingStates;

   206     mReader->setCurrentState(*mReader->mModifyingStates[0]);

   207     QVERIFY( mReader->mCurrentStateIndex == 0 );

   208     

   209     mReader->mIndex = 1;

   210     int& index = mReader->index();

   211     QVERIFY( index == 1 );

   212     index++;

   213     QVERIFY( mReader->index() = index );

   214     

   215     QVERIFY( &mReader->events() == &mEvents );

   216     QVERIFY( &mReader->strings() == &mStrings );

   217     QVERIFY( &mReader->reqStatus() == &mReader->iStatus );

   218 

   219 }

   220 

   221 void UT_LogsReader::testViewChange()

   222 {

   223     mReader->Cancel();

   224     mReader->HandleLogClientChangeEventL(KLogClientChangeEventLogCleared, 0, 0, 0);

   225     QVERIFY( mReader->IsActive() );

   226     

   227     mReader->Cancel();

   228     mReader->HandleLogClientChangeEventL(KNullUid, 0, 0, 0);

   229     QVERIFY( !mReader->IsActive() );

   230     

   231     mReader->Cancel();

   232     mReader->HandleLogViewChangeEventAddedL(0, 0, 0, 2);

   233     QVERIFY( mReader->IsActive() );

   234     

   235     mReader->Cancel();

   236     mReader->HandleLogViewChangeEventChangedL(0, 0, 0, 1);

   237     QVERIFY( mReader->IsActive() );

   238     

   239     // Deletion has optimization to reduce multiple actions for same deletion

   240     // patch

   241     mReader->Cancel();

   242     mReader->HandleLogViewChangeEventDeletedL(0, 0, 1, 2);

   243     QVERIFY( mReader->IsActive() );

   244     

   245     mReader->Cancel();

   246     mReader->HandleLogViewChangeEventDeletedL(0, 0, 0, 2);

   247     QVERIFY( !mReader->IsActive() );

   248     

   249     mReader->Cancel();

   250     mReader->HandleLogViewChangeEventDeletedL(0, 0, 0, 1);

   251     QVERIFY( mReader->IsActive() );

   252     

   253 }

   254 

   255 void UT_LogsReader::testUpdateDetails()

   256 {

   257     QVERIFY( !mReader->IsActive() );

   258     ContactCacheEntry contactEntry("name", 1);

   259     mReader->mContactCache.insert("12345", contactEntry);

   260     mReader->updateDetails(false);

   261     QVERIFY( !mReader->IsActive() );

   262     QVERIFY( mReader->mContactCache.count() == 1 );

   263     

   264     mReader->updateDetails(true);

   265     QVERIFY( !mReader->IsActive() );

   266     QVERIFY( mReader->mContactCache.count() == 0 );    

   267 }

   268 

   269 

   270 // ----------------------------------------------------------------------------

   271 // From LogsReaderObserver

   272 // ----------------------------------------------------------------------------

   273 //

   274 void UT_LogsReader::readCompleted(int /*readCount*/)

   275 {

   276 

   277 }

   278 

   279 // ----------------------------------------------------------------------------

   280 // From LogsReaderObserver

   281 // ----------------------------------------------------------------------------

   282 //

   283 void UT_LogsReader::errorOccurred(int err)

   284 {

   285     mErrorOccurred = true;

   286     mError = err;

   287 }

   288 

   289 // ----------------------------------------------------------------------------

   290 // From LogsReaderObserver

   291 // ----------------------------------------------------------------------------

   292 //

   293 void UT_LogsReader::temporaryErrorOccurred(int err)

   294 {

   295     mError = err;

   296 }

   297 

   298 // ----------------------------------------------------------------------------

   299 // From LogsReaderObserver

   300 // ----------------------------------------------------------------------------

   301 //

   302 void UT_LogsReader::eventModifyingCompleted()

   303 {

   304 

   305 }

   306 

   307 // ----------------------------------------------------------------------------

   308 // From LogsReaderObserver

   309 // ----------------------------------------------------------------------------

   310 //

   311 void UT_LogsReader::duplicatesReadingCompleted(QList<LogsEvent*> duplicates)

   312 {

   313     qDeleteAll(duplicates);

   314 }