/*
* 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 mcsplugin handler
*
*/


//  CLASS HEADER
#include "ut_sapidata.h"


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

//  INTERNAL INCLUDES
#define private public
#include "sapidata.h"
#undef private
#include "sapidataplugin.h"
#include "observer.h"

// Implementation of the MTest interface
void MTest::GetMenuItemsL()
	{
	
	}

// CONSTRUCTION

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

    return self;
    }

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

    self->ConstructL();

    return self;
    }

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

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

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

// ---------------------------------------------------------------------------
// void UT_SapiDataPlugin::SetupL()
// ---------------------------------------------------------------------------
//
void UT_SapiData::SetupL()
    {
    iContentObserver = Observer::NewL();    
    TUid uid = { SAPIDP_UID_ECOM_IMPLEMENTATION_CONTENTPUBLISHER_DATAPLUGIN };

    iPlugin = CSapiDataPlugin::NewL();

    // Array owned by the plugin
    RAiSettingsItemArray settings;
    settings.ReserveL( 3 );
    
    MAiPluginSettings* configuration( AiUtility::CreatePluginSettingsL() );
    CleanupDeletePushL( configuration );
       
    MAiPluginConfigurationItem& confItem = configuration->AiPluginConfigurationItem();
    confItem.SetOwnerL( KPlugin );
    confItem.SetNameL( KPublisher );
    confItem.SetValueL( KMtSapiDataPlugin );

    settings.AppendL( configuration );
    CleanupStack::Pop( configuration );
                
    // No publisher there, set empty
    iPlugin->ConfigureL( settings );
    iPlugin->SubscribeL( *iContentObserver );
    iPlugin->Start( CHsContentPublisher::ESystemStartup );
    iPlugin->Resume( CHsContentPublisher::EForeground );
    
    CleanupStack::PushL( iPlugin );
    iData = CSapiData::NewL( iPlugin );
    CleanupStack::Pop( iPlugin );
    iData->SetContentIdL( KId );
    iData->ConfigureL( settings );
    }

// ---------------------------------------------------------------------------
// void UT_SapiDataPlugin::Teardown()
// ---------------------------------------------------------------------------
//
void UT_SapiData::Teardown()
    {
    if ( iContentObserver )
        {
        delete iContentObserver;
        iContentObserver = NULL;
        }
    if ( iData )
        {
        delete iData;
        iData = NULL;
        }
    if ( iPlugin )
        {
        delete iPlugin;
        iPlugin = NULL;
        }
    }

// ---------------------------------------------------------------------------
// void UT_SapiData::TestConfigureL()
// ---------------------------------------------------------------------------
//
void UT_SapiData::TestConfigureL()
	{
    RAiSettingsItemArray configurationItemsArr;
    configurationItemsArr.ReserveL( 1 );
    
    MAiPluginSettings* settings( AiUtility::CreatePluginSettingsL() );
    CleanupDeletePushL( settings );
    
    MAiPluginSettingsItem& item( settings->AiPluginSettingsItem() ); 
    item.SetPublisherId( TUid::Uid( 3 ) );

    _LIT( KPlugin, "plugin" );
    _LIT( KPublisher16,  "publisher" );
    MAiPluginConfigurationItem& confItem = settings->AiPluginConfigurationItem();
    confItem.SetOwnerL( KPlugin );
    confItem.SetNameL( KPublisher16 );
    
    TInt32 key( 0 );
    
    item.SetKey( key );
    _LIT( KValue, "value" );
    item.SetValueL( KValue, EFalse );
    
    configurationItemsArr.Append( settings );            
    CleanupStack::Pop( settings );
    
    
    EUNIT_ASSERT_NO_LEAVE( iData->ConfigureL( configurationItemsArr ) );
    
    //delete settings;
    configurationItemsArr.ResetAndDestroy();
	}

// ---------------------------------------------------------------------------
// void UT_SapiData::TestSetContentIdL()
// ---------------------------------------------------------------------------
//
void UT_SapiData::TestSetContentIdL()
	{
	_LIT8( KId, "11" );
	EUNIT_ASSERT_NO_LEAVE( iData->SetContentIdL( KId ) );
	}

// ---------------------------------------------------------------------------
// void UT_SapiData::TestSetStartupReasonL()
// ---------------------------------------------------------------------------
//
void UT_SapiData::TestSetStartupReasonL()
	{
	_LIT8( KStartupReason, "startup_reason" );
	EUNIT_ASSERT_LEAVE( iData->SetStartupReasonL( KStartupReason ) );
	}

// ---------------------------------------------------------------------------
// void UT_SapiData::TestIsPluginActive()
// ---------------------------------------------------------------------------
//
void UT_SapiData::TestIsPluginActive()
	{
	TBool res = iData->IsPluginActive();
	EUNIT_ASSERT( res );
	}

// ---------------------------------------------------------------------------
// void UT_SapiData::TestChangePublisherStatusL()
// ---------------------------------------------------------------------------
//
void UT_SapiData::TestChangePublisherStatusL()
	{
	_LIT8( KStatus, "new_status" );
	
	iData->SetUpdateNeeded( ETrue );
	EUNIT_ASSERT_LEAVE( iData->ChangePublisherStatusL( KStatus ) );

	iData->SetUpdateNeeded( EFalse );
	EUNIT_ASSERT_LEAVE( iData->ChangePublisherStatusL( KStatus ) );
	}

// ---------------------------------------------------------------------------
// void UT_SapiData::TestTriggerActiveL()
// ---------------------------------------------------------------------------
//
void UT_SapiData::TestTriggerActiveL()
	{
	EUNIT_ASSERT_LEAVE( iData->TriggerActiveL() );
	}

// ---------------------------------------------------------------------------
// void UT_SapiData::TestUpdatePublisherStatusL()
// ---------------------------------------------------------------------------
//
void UT_SapiData::TestUpdatePublisherStatusL()
	{
	TBuf<10> publisher;
	publisher.Append( _L("publisher") );
	EUNIT_ASSERT_NO_LEAVE( iData->UpdatePublisherStatusL( publisher) );
	}

// ---------------------------------------------------------------------------
// void UT_SapiData::TestCanUpdate()
// ---------------------------------------------------------------------------
//
void UT_SapiData::TestCanUpdate()
	{
	TBuf<20> KId_EU;
	KId_EU.Append( _L("4"));

	TBuf<20> KAll_EU;
	KAll_EU.Append( _L("all"));

	TBufC<30> KPublisher_EU ( KMtSapiDataPlugin );

	
	EUNIT_ASSERT( iData->CanUpdate( KPublisher_EU, KAll_EU, KId_EU ) );
	}

// ---------------------------------------------------------------------------
// void UT_SapiData::TestGetMenuItemsL()
// ---------------------------------------------------------------------------
//
void UT_SapiData::TestGetMenuItemsL()
	{
	MTest* test;
	
	test = reinterpret_cast<MTest*> ( iData );
	
	EUNIT_ASSERT_NO_LEAVE( test->GetMenuItemsL() );	
	}

// ---------------------------------------------------------------------------
// void UT_SapiData::TestHasMenuItem()
// ---------------------------------------------------------------------------
//
void UT_SapiData::TestHasMenuItem()
	{
	_LIT16( KParam, "hello world" );
	EUNIT_ASSERT( !iData->HasMenuItem(KParam) );
	}

// ---------------------------------------------------------------------------
// void UT_SapiData::TestRemoveL()
// ---------------------------------------------------------------------------
//
void UT_SapiData::TestRemoveL()
	{
	TBuf<10> KAll;
	KAll.Append( _L("all") );	

	Observer* observer = Observer::NewL();
	
	EUNIT_ASSERT_NO_LEAVE( iData->RemoveL(observer, KAll) );	
	
	delete observer;
	}

// ---------------------------------------------------------------------------
// void UT_SapiData::TestRefreshL()
// ---------------------------------------------------------------------------
//
void UT_SapiData::TestRefreshL()
	{   
	TBuf<20> publisher;
	publisher.Append( _L("mt_sapi_plugin") );
	TBuf<10> contentType;
	contentType.Append( _L("all") );
	TBuf<10> contentId;
	contentId.Append( _L("4") );
	TBuf<10> operation;
	operation.Append( _L("operation") );
    CLiwDefaultMap* dataMap;
    
    iData->CanUpdate( publisher, contentType, contentId );
    iData->RefreshL( publisher, contentType, contentId, operation, dataMap );
    
    TInt id = 4;
    iPlugin->Clean(iContentObserver, id );
	}

//  TEST TABLE

EUNIT_BEGIN_TEST_TABLE
    (
    UT_SapiData,
    "Sapidata plugin tests",
    "UNIT"
    )

EUNIT_TEST
	(
	"Test configure",
	"CSapiData",
	"ConfigureL",
	"FUNCTIONALITY",
	SetupL, TestConfigureL, Teardown
    )
    
EUNIT_TEST
	(
	"Test refresh",
	"CSapiData",
	"RefreshL",
	"FUNCTIONALITY",
	SetupL, TestRefreshL, Teardown
    )

EUNIT_TEST
    (
    "Test set content ID",
    "CSapiData",
    "SetContentIdL",
    "FUNCTIONALITY",
    SetupL, TestSetContentIdL, Teardown
    )

EUNIT_TEST
    (
    "Test set startup reason",
    "CSapiData",
    "SetStartupReasonL",
    "FUNCTIONALITY",
    SetupL, TestSetStartupReasonL, Teardown
    )
    
EUNIT_TEST
    (
    "Test is plugin active",
    "CSapiData",
    "IsPluginActive",
    "FUNCTIONALITY",
    SetupL, TestIsPluginActive, Teardown
    )
    
EUNIT_TEST
    (
    "Test change publisher status",
    "CSapiData",
    "ChangePublisherStatusL",
    "FUNCTIONALITY",
    SetupL, TestChangePublisherStatusL, Teardown
    )

EUNIT_TEST
    (
    "Test trigger activate",
    "CSapiData",
    "TriggerActivateL",
    "FUNCTIONALITY",
    SetupL, TestTriggerActiveL, Teardown
    )

EUNIT_TEST
    (
    "Test update publisher status",
    "CSapiData",
    "UpdatePublisherStatusL",
    "FUNCTIONALITY",
    SetupL, TestUpdatePublisherStatusL, Teardown
    )
    
EUNIT_TEST
    (
    "Test can update",
    "CSapiData",
    "CanUpdate",
    "FUNCTIONALITY",
    SetupL, TestCanUpdate, Teardown
    )
    
EUNIT_TEST
    (
    "Test get menu items",
    "CSapiData",
    "GetMenuItemsL",
    "FUNCTIONALITY",
    SetupL, TestGetMenuItemsL, Teardown
    )
    
EUNIT_TEST
    (
    "Test has menu item",
    "CSapiData",
    "HasMenuItem",
    "FUNCTIONALITY",
    SetupL, TestHasMenuItem, Teardown
    )
    
EUNIT_TEST
    (
    "Test remove",
    "CSapiData",
    "RemoveL",
    "FUNCTIONALITY",
    SetupL, TestRemoveL, Teardown
    )

EUNIT_END_TEST_TABLE

//  END OF FILE