/*
* Copyright (c) 2008-2008 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:  Conflict checker unit and module tests
*  Version     : %version: e002sa33#4 % 
*
*  Copyright ? 2008-2008 Nokia.  All rights reserved.
*/


#include "UT_CESMRConflictChecker.h"

// SYSTEM INCLUDES
#include <EUnitMacros.h>
#include <EUnitDecorators.h>

#include <aknutils.h>
#include <calsession.h>
#include <calinstance.h>
#include <calinstanceview.h>

// USER INCLUDES
#include "cesmrconflictchecker.h"
#include "cesmrcaldbmgr.h"

// CONSTANTS

// LOCAL DEFINITIONS

namespace {

_LIT(KTimeFormat,"%F%Y/%M/%D,%H:%T:%S");

// Conflicting entry's start time (yyyymmdd::hhmmss).
_LIT( KConflictingCalendarEntryStartTime, "20091100:140000" );
//-TODO:luo _LIT( KConflictingCalendarEntryStartTime, "20090000:150000" );
// Conflicting entry's end time (yyyymmdd::hhmmss).
_LIT( KConflictingCalendarEntryEndTime, "20091100:150000");
//-TODO:luo _LIT( KConflictingCalendarEntryEndTime, "20090000:170000");
// Calendar entry's location for conflicting entries.
_LIT( KCalendarEntryTrueValue, "1" );

// Recurrent event start and end time.
_LIT( KRecurrentCalendarEntryStartTime, "20091100:140000" );
_LIT( KRecurrentCalendarEntryEndTime, "20091100:150000" );

// Time range for fetching recurrent event instances.
_LIT( KRecurrentEntryTimeRangeStartTime, "20091100:000000" );
_LIT( KRecurrentEntryTimeRangeEndTime, "20091106:000000" );

// Calendar database filename.
_LIT( KCalendarDatabaseFilePath, "c:calendar3");//"c:Calendar_test_conflictchecker" );
// Calendar entry UID.
_LIT8( KCalendarEntryUid, "UT_ConflictChecker" );
}

// - Construction ------------------------------------------------------------

// ---------------------------------------------------------------------------
// UT_CESMRConflictChecker::NewL
// ---------------------------------------------------------------------------
//
UT_CESMRConflictChecker* UT_CESMRConflictChecker::NewL()
    {
    UT_CESMRConflictChecker* self = UT_CESMRConflictChecker::NewLC();
    CleanupStack::Pop();
    return self;
    }

// ---------------------------------------------------------------------------
// UT_CESMRConflictChecker::NewLC
// ---------------------------------------------------------------------------
//
UT_CESMRConflictChecker* UT_CESMRConflictChecker::NewLC()
    {
    UT_CESMRConflictChecker* self = new( ELeave ) UT_CESMRConflictChecker();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ---------------------------------------------------------------------------
// UT_CESMRConflictChecker::~UT_CESMRConflictChecker
// ---------------------------------------------------------------------------
//
UT_CESMRConflictChecker::~UT_CESMRConflictChecker()
    {
    delete iWait;
    }

// ---------------------------------------------------------------------------
// UT_CESMRConflictChecker::UT_CESMRConflictChecker
// ---------------------------------------------------------------------------
//
UT_CESMRConflictChecker::UT_CESMRConflictChecker()
    {
    }

// ---------------------------------------------------------------------------
// UT_CESMRConflictChecker::ConstructL
// ---------------------------------------------------------------------------
//
void UT_CESMRConflictChecker::ConstructL()
    {
    CEUnitTestSuiteClass::ConstructL();
    iWait = new ( ELeave) CActiveSchedulerWait();
    }

// ---------------------------------------------------------------------------
// UT_CESMRConflictChecker::HandleCalEngStatus
// ---------------------------------------------------------------------------
//
void UT_CESMRConflictChecker::HandleCalEngStatus( TMRUtilsCalEngStatus aStatus )
    {
    iWait->AsyncStop();
    }

// - Test methods -----------------------------------------------------------


// ---------------------------------------------------------------------------
// UT_CESMRConflictChecker::SetupL
// ---------------------------------------------------------------------------
//
void UT_CESMRConflictChecker::SetupL()
    {
    __UHEAP_MARK;
    iCalSession = CCalSession::NewL();
    iCalSession->OpenL( KCalendarDatabaseFilePath );
    iCalDbManager = CESMRCalDbMgr::NewL( *iCalSession, *this );
    iWait->Start();
    iConflictChecker = CESMRConflictChecker::NewL( *iCalDbManager );
    }
    
// ---------------------------------------------------------------------------
// UT_CESMRConflictChecker::Teardown
// ---------------------------------------------------------------------------
//
void UT_CESMRConflictChecker::Teardown()
    {
    delete iConflictChecker;
    delete iCalDbManager;
    delete iCalSession;
    __UHEAP_MARKEND;
    }

// ---------------------------------------------------------------------------
// UT_CESMRConflictChecker::T_Global_NewL
// ---------------------------------------------------------------------------
//
void UT_CESMRConflictChecker::T_Global_NewL()
    {
    delete iConflictChecker;
    iConflictChecker = NULL;
    
    __UHEAP_MARK;
    iConflictChecker = CESMRConflictChecker::NewL( *iCalDbManager );
    delete iConflictChecker;
    __UHEAP_MARKEND;
    
    iConflictChecker = NULL;
    }

// ---------------------------------------------------------------------------
// UT_CESMRConflictChecker::T_Global_FindConflictsL
// ---------------------------------------------------------------------------
//
void UT_CESMRConflictChecker::T_Global_FindConflictsL()
    {
    // Create reference calendar entry.
    HBufC8* entryUidBufC = KCalendarEntryUid().AllocLC();
    CCalEntry* calEntry = CCalEntry::NewL( CCalEntry::EAppt, entryUidBufC, CCalEntry::EMethodRequest, 0 );
    CleanupStack::Pop( entryUidBufC );
    entryUidBufC = NULL;
    
    TTime startTime, endTime;
    TCalTime startCalTime, endCalTime;
    
    startTime.Set( KConflictingCalendarEntryStartTime );
    endTime.Set( KConflictingCalendarEntryEndTime );

    TBuf<32> sTime;
    TBuf<32> eTime;
    startTime.FormatL( sTime, KTimeFormat );    
    endTime.FormatL(  eTime, KTimeFormat );
    
    startCalTime.SetTimeLocalL( startTime );
    endCalTime.SetTimeLocalL( endTime );
    
    calEntry->SetStartAndEndTimeL( startCalTime, endCalTime );
    
    // Fetch conflicting entries.
    RPointerArray<CCalEntry> conflictList;
    CleanupClosePushL( conflictList );
    
    iConflictChecker->FindConflictsL( *calEntry, conflictList );
    delete calEntry;
    calEntry = NULL;
    
    // Check that correct number of entries is returned.
    EUNIT_ASSERT_DESC( conflictList.Count() == 4,
            "Incorrect number of calendar entries." );
    
    // Verify list of conflicting entries.
    TBool testFailed = EFalse;
    while ( conflictList.Count() )
        {
        // If entry's location is something else than '1'.
        if ( conflictList[ 0 ]->LocationL().Compare( KCalendarEntryTrueValue ) )
            {
            testFailed = ETrue;
            }
        
        // Remove entry from array.
        delete conflictList[ 0 ];
        conflictList.Remove( 0 );
        }
    
    // Check that correct entries were returned.
    EUNIT_ASSERT_DESC( !testFailed,
            "Incorrect calendar entry/ies returned.");
    
    CleanupStack::PopAndDestroy(); // conflictList
    }

// ---------------------------------------------------------------------------
// UT_CESMRConflictChecker::T_Global_FindInstancesForEntryL
// ---------------------------------------------------------------------------
//
void UT_CESMRConflictChecker::T_Global_FindInstancesForEntryL()
    {
    // First retrieve one instace of recurrent event.
    RPointerArray<CCalInstance> instanceList;
    MESMRCalDbMgr& dbMgr = *iCalDbManager;
    CCalInstanceView* instanceView = dbMgr.NormalDbInstanceView();
    CalCommon::TCalViewFilter calViewFilter( CalCommon::EIncludeAppts );
    
    TTime startTime, endTime;
    TCalTime startCalTime, endCalTime;
    
    startTime.Set( KRecurrentCalendarEntryStartTime );
    endTime.Set( KRecurrentCalendarEntryEndTime );

    TBuf<32> sTime;
    TBuf<32> eTime;
    startTime.FormatL( sTime, KTimeFormat );    
    endTime.FormatL(  eTime, KTimeFormat );
    
    startCalTime.SetTimeLocalL( startTime );
    endCalTime.SetTimeLocalL( endTime );
    
    instanceView->FindInstanceL(
            instanceList,
            calViewFilter,
            CalCommon::TCalTimeRange( startCalTime, endCalTime ) );
    
    EUNIT_ASSERT_DESC( instanceList.Count() == 2,
            "Incorrect number of instances returned.");
    
    CCalEntry& calEntry = instanceList[0]->Entry();
    
    // Set time range.
    startTime.Set( KRecurrentEntryTimeRangeStartTime );
    endTime.Set( KRecurrentEntryTimeRangeEndTime );
    
    startCalTime.SetTimeLocalL( startTime );
    endCalTime.SetTimeLocalL( endTime );
    
    // Fetch recurrent event instances.
    RPointerArray<CCalEntry> entryList;
    iConflictChecker->FindInstancesForEntryL( startTime, endTime, calEntry, entryList );
    
    EUNIT_ASSERT_DESC( entryList.Count() == 6,
            "Incorrect number of calendar entry instances returned.");
    
    // Clear entry/instance lists.
    while ( instanceList.Count() )
        {
        delete instanceList[ 0 ];
        instanceList.Remove( 0 );
        }
    while ( entryList.Count() )
        {
        delete entryList[ 0 ];
        entryList.Remove( 0 );
        }
    instanceList.Close();
    entryList.Close();
    }

// - EUnit test table --------------------------------------------------------

EUNIT_BEGIN_TEST_TABLE(
    UT_CESMRConflictChecker,
    "CESMRConflictChecker unit and module tests.",
    "UNIT" )

EUNIT_TEST(
    "NewL",
    "CESMRConflictChecker",
    "NewL",
    "FUNCTIONALITY",
    SetupL, T_Global_NewL, Teardown )
    
EUNIT_TEST(
    "FindConflictsL",
    "CESMRConflictChecker",
    "FindConflictsL",
    "FUNCTIONALITY",
    SetupL, T_Global_FindConflictsL, Teardown )
    
EUNIT_TEST(
    "FindInstancesForEntryL",
    "CESMRConflictChecker",
    "FindInstancesForEntryL",
    "FUNCTIONALITY",
    SetupL, T_Global_FindInstancesForEntryL, Teardown )
    
EUNIT_END_TEST_TABLE