/*
* Copyright (c) 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: unit test for the sapidataobserver
*
*/


//  CLASS HEADER
#include "ut_sapidataobserver.h"

//  EXTERNAL INCLUDES
#include <digia/eunit/eunitmacros.h>
#include <e32cmn.h>

//  INTERNAL INCLUDES
#include "sapidata.h"
#include "sapidataobserver.h"
#include "sapidataplugin.h"
#include "sapidatapluginconst.h"

// CONSTRUCTION

// ---------------------------------------------------------------------------
// UT_SapiDataObserver* UT_SapiDataObserver::NewL()
// ---------------------------------------------------------------------------
//
UT_SapiDataObserver* UT_SapiDataObserver::NewL()
    {
    UT_SapiDataObserver* self = UT_SapiDataObserver::NewLC();
    CleanupStack::Pop();

    return self;
    }

// ---------------------------------------------------------------------------
// UT_SapiDataObserver* UT_SapiDataObserver::NewLC()
// ---------------------------------------------------------------------------
//
UT_SapiDataObserver* UT_SapiDataObserver::NewLC()
    {
    UT_SapiDataObserver* self = new(ELeave) UT_SapiDataObserver();
    CleanupStack::PushL(self);

    self->ConstructL();

    return self;
    }

// ---------------------------------------------------------------------------
// Destructor (virtual by CBase)
// ---------------------------------------------------------------------------
//
UT_SapiDataObserver::~UT_SapiDataObserver()
    {
    
    }

// ---------------------------------------------------------------------------
// Default constructor
// ---------------------------------------------------------------------------
//
UT_SapiDataObserver::UT_SapiDataObserver()
    {
    
    }

// ---------------------------------------------------------------------------
// Second phase construct
// ---------------------------------------------------------------------------
//
void UT_SapiDataObserver::ConstructL()
    {
    // The ConstructL from the base class CEUnitTestSuiteClass must be called.
    // It generates the test case table.
    CEUnitTestSuiteClass::ConstructL();
    }

// ---------------------------------------------------------------------------
// Auxiliary method for the obtaining of the MLiwInterface
// ---------------------------------------------------------------------------
//
MLiwInterface* UT_SapiDataObserver::GetMessagingInterfaceL()
	{
	if( !iServiceHandler )
		{
		iServiceHandler = CLiwServiceHandler::NewL();
		}
	
	CLiwGenericParamList* inParam = CLiwGenericParamList::NewL();
	CleanupStack::PushL( inParam );
	CLiwGenericParamList* outParam = CLiwGenericParamList::NewL();
	CleanupStack::PushL( outParam );
	CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL( KLiwCmdAsStr, KCPInterface,
		KCPService  );
	crit->SetServiceClass( TUid::Uid(KLiwClassBase) );
	
	RCriteriaArray a;
	a.AppendL(crit);    
	
	iServiceHandler->AttachL(a);
	iServiceHandler->ExecuteServiceCmdL( *crit, *inParam, *outParam ); 
	
	delete crit;
	a.Reset();
	
	// find service interface
	TInt pos = 0;
	MLiwInterface* msgInterface = NULL;
	outParam->FindFirst( pos, KCPInterface );
	if ( pos != KErrNotFound ) 
	    {
	    msgInterface = (*outParam)[pos].Value().AsInterface(); 
	    }
	
	outParam->Reset();
	inParam->Reset();
	CleanupStack::PopAndDestroy( outParam );
	CleanupStack::PopAndDestroy( inParam );
	
	return msgInterface;	
	}

// ---------------------------------------------------------------------------
// void UT_SapiDataObserver::SetupL()
// ---------------------------------------------------------------------------
//
void UT_SapiDataObserver::SetupL()
    {
    iInterface = GetMessagingInterfaceL();    
    iPlugin = CSapiDataPlugin::NewL();    
    iData = CSapiData::NewL( iPlugin );
    iObserver = CSapiDataObserver::NewL( iInterface, iData );
    
    CLiwDefaultMap* filter = CLiwDefaultMap::NewLC();
    filter->InsertL( KPublisherId, TLiwVariant( KPublisherId ));	
	filter->InsertL( KOperation, TLiwVariant( KAddUpdateDelete ) );
	iObserver->RegisterL( filter, KCpData(), 
                                 KExtendedNotifications );
	CleanupStack::PopAndDestroy( filter );
    }

// ---------------------------------------------------------------------------
// void UT_SapiDataObserver::Teardown()
// ---------------------------------------------------------------------------
//
void UT_SapiDataObserver::Teardown()
    {
    if ( iObserver )
        {
		iObserver->ReleaseL();
        delete iObserver;
        iObserver = NULL;
        }
    if( iInterface )
    	{
		iInterface->Close();
		iInterface = NULL;
    	}
   	if( iServiceHandler )
    	{
    	iServiceHandler->Reset();
    	delete iServiceHandler;
    	iServiceHandler = NULL;
    	}
    if ( iData )
        {
        delete iData;
        iData = NULL;
        }
    if ( iPlugin )
        {
        delete iPlugin;
        iPlugin = NULL;
        }
    }

// ---------------------------------------------------------------------------
// void UT_SapiDataObserver::HandleSessionEventL()
// ---------------------------------------------------------------------------
//
void UT_SapiDataObserver::ConstructTestL()
    {
    if ( iObserver )
        EUNIT_ASSERT( ETrue )
    else
        EUNIT_ASSERT( EFalse );
    }

// ---------------------------------------------------------------------------
// void UT_SapiDataObserver::RegisterTestL()
// ---------------------------------------------------------------------------
//
void UT_SapiDataObserver::RegisterTestL()
    {
    CLiwDefaultMap* conRegFilter = iData->CreateFilterLC();
    conRegFilter->InsertL( KOperation, TLiwVariant( KAddUpdateDelete ) );
    
    EUNIT_ASSERT_NO_LEAVE( iObserver->RegisterL( conRegFilter, KCpData(), KExtendedNotifications ));
    
    CleanupStack::PopAndDestroy( conRegFilter );
    }

// ---------------------------------------------------------------------------
// void UT_SapiDataObserver::ReleaseTestL()
// ---------------------------------------------------------------------------
//
void UT_SapiDataObserver::ReleaseTestL()
    {
    EUNIT_ASSERT_NO_LEAVE( iObserver->ReleaseL() );
    
    delete iObserver;
    iObserver = NULL;
    }

// ---------------------------------------------------------------------------
// void UT_SapiDataObserver::HandleNotifyTestL()
// ---------------------------------------------------------------------------
//
void UT_SapiDataObserver::HandleNotifyTestL()
    {
    CLiwGenericParamList* paramList = CLiwGenericParamList::NewL();
    TInt id = 999;
    TInt retValue = 0;
    
    retValue = iObserver->HandleNotifyL( id, 0, *paramList, *paramList );
    
    if ( retValue == id )    
        EUNIT_ASSERT( ETrue )
    else
        EUNIT_ASSERT( EFalse );
    }

//  TEST TABLE

EUNIT_BEGIN_TEST_TABLE
    (
    UT_SapiDataObserver,
    "Sapidata Observer tests",
    "UNIT"
    )

EUNIT_TEST
    (
    "Tests ConstructL()",
    "CSapiDataObserver",
    "ConstructL",
    "FUNCTIONALITY",
    SetupL, ConstructTestL, Teardown
    )

EUNIT_TEST
    (
    "Tests RegisterL()",
    "CSapiDataObserver",
    "RegisterL",
    "FUNCTIONALITY",
    SetupL, RegisterTestL, Teardown
    )

EUNIT_TEST
    (
    "Tests ReleaseL()",
    "CSapiDataObserver",
    "ReleaseL",
    "FUNCTIONALITY",
    SetupL, ReleaseTestL, Teardown
    )
    
EUNIT_TEST
    (
    "Tests HandleNotify()",
    "CSapiDataObserver",
    "HandleNotifyL",
    "FUNCTIONALITY",
    SetupL, HandleNotifyTestL, Teardown
    )
 
EUNIT_END_TEST_TABLE

//  END OF FILE