/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  The Feeds project test harness.

*

*/

#include "Logger.h"

#include "StatusPane.h"

#include "TestHarness.h"

#include "FeedsWaitDialog.h"

#include <FeedsApp.Rsg>

//const TInt NTFolderListId = 270501633;

// default id: browser

const TInt NTFolderListId = 0;

// The pair is used testing feed with same name, url, different folder list Id should have 2 entries in database

// The default.xml should contain the same feed with folder list Id as 0

_LIT(KNewTitle, "Slashdot");

_LIT(KUrl, "http://rss.slashdot.org/Slashdot/slashdot");

//

//_LIT(KNewTitle, "New");

_LIT(KRenamedTitle, "Renamed");

//_LIT(KUrl, "http://xml.newsisfree.com/feeds/39/1439.xml");

_LIT(KChangedUrl, "http://www.theshiftedlibrarian.com/rss.xml");

// http://www.microsite.reuters.com/rss/topNews

// http://dictionary.reference.com/wordoftheday/wotd.rss

// -----------------------------------------------------------------------------

// CTestHarness::NewL

//

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CTestHarness* CTestHarness::NewL(MTestHarnessObserver& aObserver)

    {

    CTestHarness* self = new (ELeave) CTestHarness(aObserver);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// -----------------------------------------------------------------------------

// CTestHarness::CTestHarness

//

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CTestHarness::CTestHarness(MTestHarnessObserver& aObserver):

        iObserver(aObserver), iFeedsServer(*this, NTFolderListId), iRootFolder(*this, NTFolderListId, ETrue), iFeed(*this), 

        iIsConnected(EFalse), iWaitDialog(NULL)

    {

    LEAK_TRACKER_INCREMENT(CLeakTracker::ETestHarness);

    }

// -----------------------------------------------------------------------------

// CTestHarness::ConstructL

//

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CTestHarness::ConstructL()

    {

    _LIT(KInfoPath, "\\logs\\feeds\\info.txt");

    _LIT(KStatusPath, "\\logs\\feeds\\status.txt");

    TInt  err;

    // Connect to the file server.

    User::LeaveIfError(iFs.Connect());

    // If need be create the log dir.

    err = iFs.MkDirAll(KInfoPath);

    if (err != KErrAlreadyExists)

        {

        User::LeaveIfError(err);

        }

    // Create the log file.

    User::LeaveIfError(iLogFile.Replace(iFs, KInfoPath, EFileWrite));

    User::LeaveIfError(iStatusFile.Replace(iFs, KStatusPath, EFileWrite));

    iConMgr = CInternetConnectionManager::NewL(ETrue);

    // Create the WaitDialog

    if (iWaitDialog == NULL)

        {        

        iWaitDialog = CFeedsWaitDialog::NewL( *this );

        }

    // Connect to the server.

    ConnectToServerL();

    }        

// -----------------------------------------------------------------------------

// CTestHarness::~CTestHarness

//

// Deconstructor.

// -----------------------------------------------------------------------------

//

CTestHarness::~CTestHarness()

    {

    LEAK_TRACKER_DECREMENT(CLeakTracker::ETestHarness);

    delete iIdle;

    delete iDirPath;

    delete iCurrentFeedUrl;

	//++pK: Check for NULL

	if( iConMgr != NULL )

	{

		iConMgr->Disconnect();	

	}

    delete iConMgr;

    delete iWaitDialog;   

    DisconnectFromServer();

    iLogFile.Close();

    iStatusFile.Close();

    iFs.Close();

    }

// -----------------------------------------------------------------------------

// CTestHarness::Start

//

// Start the test harness.

// -----------------------------------------------------------------------------

//

void CTestHarness::Start(TTestSuite aSuite, TInt aStartAt)

    {

#if !defined( __WINS__ ) && !defined( __WINSCW__ )

#define REMOTE

#endif

#ifdef REMOTE

    _LIT(KCanned, "http://waplabdc.nokia-boston.com/browser/users/rss/feeds_canned_rss/");

    _LIT(KCannedAtom, "http://waplabdc.nokia-boston.com/browser/users/rss/feeds_canned_atom/");

    //_LIT(KLive, "http://waplabdc.nokia-boston.com/browser/users/rss/live.opml");

#else

    _LIT(KCanned, "file://c:/feeds_canned_rss/");

    _LIT(KCannedAtom, "file://c:/feeds_canned_atom/");

    //_LIT(KLive, "file://c:/live.opml");

#endif

    TInt err = KErrNone;

    iOperation = EParser;

    switch (aSuite)

        {

        case ECanned:

            TRAP(err, TestFeedsL(KCanned, 0, 2530));

            break;

        case ECannedShort:

            TRAP(err, TestFeedsL(KCanned, 0, 100));

            break;

        case ECannedStartAt:

            TRAP(err, TestFeedsL(KCanned, aStartAt, aStartAt));

            break;

        case ECannedAtom:

            TRAP(err, TestFeedsL(KCannedAtom, 0, 350));

            break;

        case ELive:

            //TRAP(err, TestFolderL(KLive));

            break;

        }

    if (err != KErrNone)

        {

        FEED_LOG1(_L("Feeds"), _L("Feeds_Errors.log"), 

                EFileLoggingModeAppend, _L("Warning!!! CTestHarness::Start failed, error[%d]."), err);

        }

    }

// -----------------------------------------------------------------------------

// CTestHarness::TestFeedL

//

// Tests a single Feed.

// -----------------------------------------------------------------------------

//

void CTestHarness::TestFeedL(const TDesC& aPath)

    {

    // Update the status pane to show some feedback to the user.

    TPtr  ptr(const_cast<TUint16*>(aPath.Ptr()), aPath.Length(), aPath.Length());

    if (ptr.Length() > 20)

        {

        ptr.Set(const_cast<TUint16*>(aPath.Ptr()) + 

                (aPath.Length() - 20), 20, 20);

        }

    StatusPane::SetTitleL(ptr);

    // Save the feed's url.

    delete iCurrentFeedUrl;

    iCurrentFeedUrl = NULL;

    iCurrentFeedUrl = aPath.AllocL();

    // Schedule the test to run after the call stack unrolls.

    iIdle = CIdle::NewL(CActive::EPriorityIdle);

    iIdle->Start(TCallBack(RunTest, this));

    }

// -----------------------------------------------------------------------------

// CTestHarness::TestFeedsL

//

// Tests all feeds in the given folder, where the feeds must be named XX.xml where

// XX are consecutive integers (ie 1.xml, 2.xml, etc.).

// -----------------------------------------------------------------------------

//

void CTestHarness::TestFeedsL(const TDesC& aDirPath, TInt aStartIndex, TInt aEndIndex)

    {

    iDirPath = aDirPath.AllocL();

    iFeedIndex = aStartIndex;

    iEndFileIndex = aEndIndex;

    iTestingFeedSeries = TRUE;

    TestNextFeedInSeriesL();

    }

// -----------------------------------------------------------------------------

// CTestHarness::TestNextFeedInSeriesL

//

// Tests a single Feed given the current value of iFeedIndex. See TestFeedsL.

// -----------------------------------------------------------------------------

//

void CTestHarness::TestNextFeedInSeriesL()

    {

    TBuf16<100> path;

    // Test the next Feed.

    if (iFeedIndex <= iEndFileIndex)

        {

        path.Format(_L("%S%d.xml"), iDirPath, iFeedIndex);

        iFeedIndex++;

        TestFeedL(path);

        }

    // Otherwise we're all done.

    else

        {

        _LIT(KDone, "Done!");

        iTestingFeedSeries = FALSE;

        // All done...

        iObserver.Completed();

        StatusPane::SetTitleL(KDone());

        }

    }

// -----------------------------------------------------------------------------

// CTestHarness::FeedRequestCompleted

//

// Called when the asynchronous request is complete.

// -----------------------------------------------------------------------------

//

// TODO: Trap the leaving methods.

void CTestHarness::FeedRequestCompleted(TInt aStatus)

    {

    // Close the wait dialog.

    iWaitDialog->Close();

    if (aStatus == KErrNone)

        {

        switch( iOperation )

            {

            case EFetchFeed:

                {

                iFeed.Feed().Debug_PrintInfo( iFeed.Feed().Url(), iLogFile );

                iFeed.Feed().Debug_Print();

                // Extract out the intial item status

                RArray<TInt>  itemIds(20);

                RArray<TItemStatus>  itemStatus(20);

                itemIds.Reset();

                itemStatus.Reset();

                TRAP_IGNORE(iFeed.Feed().ItemStatusL( itemIds, itemStatus ));

                // update folder item for unread count

                TInt     unreadCount = 0;

                for (TInt i = 0; i < itemStatus.Count(); i++)

                    {

                    if ( itemStatus[i] == EUnreadItem || itemStatus[i] == ENewItem )

                        {

                        unreadCount++;

                        }

                    }

                // unread count from folder item should be same as from feed

                FEED_LOG(_L("Feeds"), _L("Feeds_Test.log"), 

                    EFileLoggingModeAppend, _L(""));				

                FEED_LOG(_L("Feeds"), _L("Feeds_Test.log"), 

                    EFileLoggingModeAppend,

                    _L("============================================================================================================="));				

                if( !CheckRootFolderItem() )

                    {

                    return;

                    }

                CFolderItem* item = const_cast<CFolderItem*> (iRootFolder.RootFolderItem().Search( iFeed.Feed().Title() ));

                FEED_LOG2(_L("Feeds"), _L("Feeds_Test.log"), 

                    EFileLoggingModeAppend, 

                    _L("Folder Item: %d originally has unread count: %d"), item->Id(), item->UnreadCount());

                FEED_LOG2(_L("Feeds"), _L("Feeds_Test.log"), 

                    EFileLoggingModeAppend, _L("Feed: %d has unread count: %d"), iFeed.Feed().Id(), unreadCount);

                item->SetUnreadCount( unreadCount );               

                }

                break;

            case EParser:

                {

                iFeed.Feed().Debug_PrintInfo(*iCurrentFeedUrl, iLogFile);

                iFeed.Feed().Debug_Print();

                delete iCurrentFeedUrl;

                iCurrentFeedUrl = NULL;

                // Start the next local-feed test.

                if (iTestingFeedSeries == TRUE)

                    {

                    TRAPD(err, TestNextFeedInSeriesL());

                    if (err != KErrNone)

                        {

                        FEED_LOG(_L("Feeds"), _L("Feeds_Errors.log"), 

                                EFileLoggingModeAppend, _L("Warning!!! Failed to start the next test!"));

                        }

                    }

                #if 0

                    // Start the next folder-feed test.

                    else if (iTestingFolder == TRUE)

                        {

                        TRAP(err, TestNextFeedInFolderL());

                        if (err != KErrNone)

                            {

                            FEED_LOG(_L("Feeds"), _L("Feeds_Errors.log"), 

                                    EFileLoggingModeAppend, _L("Warning!!! Failed to start the next test!"));

                            }

                        }

                #endif

                }

                break;

            default:

                break;

            }

        }    

    // Otherwise show an error.

    else

        {

        // If the server terminated, reconnect to it.

        if (aStatus == KErrServerTerminated)

            {

            DisconnectFromServer();

            TRAP_IGNORE(ConnectToServerL());

            // TODO: Show the FolderView.

            }

        ShowServerError(aStatus);

        if( iOperation == EParser )

            {

            TUint8* asciiBuf = new TUint8[iCurrentFeedUrl->Length() + 50];

            if (asciiBuf != NULL)

                {

                TPtr8 asciiPtr(asciiBuf, 0, iCurrentFeedUrl->Length() + 50);

                TPtrC16 ucs2Ptr(*iCurrentFeedUrl);

                asciiPtr.Copy(_L8("Feed Completed["));

                asciiPtr.AppendNum(aStatus);

                asciiPtr.Append(_L8("]: "));

                asciiPtr.Append(ucs2Ptr);

                asciiPtr.Append(_L8("\r\n"));

                asciiPtr.ZeroTerminate();

                iStatusFile.Write(asciiPtr);

                delete asciiBuf;

                }

            }

        }

    }

// -----------------------------------------------------------------------------

// CFeedsViewMgr::NetworkConnectionNeededL

//

// Request to create a network connection.

// -----------------------------------------------------------------------------

//

void CTestHarness::NetworkConnectionNeededL(TInt* aConnectionPtr,

        TInt& aSockSvrHandle, TBool& aNewConn, TApBearerType& aBearerType) 

    {

    iConMgr->SetRequestedAP( 0 );

    // Open a connection.

    iConMgr->StartConnectionL(ETrue);                

    // Set the connection, server handler, and bearer type.

    aNewConn = ETrue;

    *aConnectionPtr = (TInt) &iConMgr->Connection();

    aSockSvrHandle = (TInt) iConMgr->SocketServer().Handle();

    aBearerType = iConMgr->CurrentBearerTypeL();

    }

// -----------------------------------------------------------------------------

// CTestHarness::RunTest

// 

// Runs the next test.

// -----------------------------------------------------------------------------

//

TInt CTestHarness::RunTest(TAny* aPtr)

    {

    CTestHarness*  self = static_cast<CTestHarness*>(aPtr);    

	// Start fetching the feed: 2nd param is the folder list ID, 0 is the default folder list ID

    TRAP_IGNORE(self->iFeed.FetchFeedL(*(self->iCurrentFeedUrl), NTFolderListId, EFalse, ETrue));	

    return EFalse;

    }

#if 0

// -----------------------------------------------------------------------------

// CTestHarness::Completed

//

// Called upon completion of the get folder task.

// -----------------------------------------------------------------------------

//

void CTestHarness::Completed(TInt /*aStatusCode*/, CFolderItem* aFolder)

    {

    // Delete the task.

    if (iGetFolderTask != NULL)

        {        

        iGetFolderTask->AutoDelete();

        iGetFolderTask = NULL;

        }        

    if (aFolder != NULL)

        {

        iFolder = aFolder;

        if (iTestingFolder == TRUE)

            {

            TRAPD(err, TestNextFeedInFolderL());

            if (err != KErrNone)

                {

                FEED_LOG(_L("Feeds"), _L("Feeds_Errors.log"), 

                        EFileLoggingModeAppend, _L("Warning!!! Failed to start the next test!"));

                }

            }

        }

    }

// -----------------------------------------------------------------------------

// CTestHarness::TestFolderL

//

// Tests all feeds in the OPML file.

// -----------------------------------------------------------------------------

//

void CTestHarness::TestFolderL(const TDesC& aPath)

    {

    // Start the task

    iGetFolderTask = CGetFolderTask::NewL(aPath, *this);

    iGetFolderTask->StartTaskL();

    iGetFolderTask->EnableAutoDeleteL();

    iTestingFolder = TRUE;

    }

// -----------------------------------------------------------------------------

// CTestHarness::TestNextFeedInFolderL

//

// Tests a single Feed given the current value of iFeedIndex. See TestFolderL.

// -----------------------------------------------------------------------------

//

void CTestHarness::TestNextFeedInFolderL()

    {

    const CFolderItem*  nextItem = NULL;

    const TDesC* url = NULL;

    while (iFeedIndex < iFolder->FolderItemCount())

        {

        // Get the next Feed.

        nextItem = iFolder->FolderItem(iFeedIndex);

        iFeedIndex++;