/*

* Copyright (c) 2006 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:    

*

*/

//  CLASS HEADER

#include "UT_CNATFWNatSettings.h"

//  EXTERNAL INCLUDES

#include <digia/eunit/eunitmacros.h>

#include <badesca.h>

#include <mnatfwicesettings.h>

//  INTERNAL INCLUDES

#include <cnatfwsettingsapi.h>

#include "cnatfwsettingsimpl.h"

#include "cnatfwserversettings.h"

#include "cnatfwstunsettings.h"

#include "cnatfwturnsettings.h"

#include <unsafprotocolscrkeys.h>

#include "natfwdefaultsettingsvalues.h"

#include "settingstore.h"

#include "natfwunittestmacros.h"

const TBool KCRLFEnabled = ETrue;

const TUint KUDPRefreshInterval = 200;

const TUint KTCPRefreshInterval = 300;

const TInt KStartPort = 4000;

const TInt KEndPort = 4100;

_LIT8( KNATProtocol, "nokia.ice,nokia.stun,nokia.turn" );

_LIT8( KNokiaStun, "nokia.stun" );

_LIT8( KNokiaTurn, "nokia.turn" );

_LIT8( KNokiaIce, "nokia.ice" );

const TBool KUseSharedSecret = ETrue; 

_LIT8(KDomain,"www.domain.fi");

const TUint KIapId = 1979;

const TUint KDefaultGranularity = 1;

// CONSTRUCTION

UT_CNATFWNatSettings* UT_CNATFWNatSettings::NewL()

    {

    UT_CNATFWNatSettings* self = UT_CNATFWNatSettings::NewLC();

    CleanupStack::Pop();

    return self;

    }

UT_CNATFWNatSettings* UT_CNATFWNatSettings::NewLC()

    {

    UT_CNATFWNatSettings* self = new( ELeave ) UT_CNATFWNatSettings();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor (virtual by CBase)

UT_CNATFWNatSettings::~UT_CNATFWNatSettings()

    {

    }

// Default constructor

UT_CNATFWNatSettings::UT_CNATFWNatSettings()

    {

    }

// Second phase construct

void UT_CNATFWNatSettings::ConstructL()

    {

    // The ConstructL from the base class CEUnitTestSuiteClass must be called.

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_CNATFWNatSettings::SetupL( )

    {

    iSettingsStore = CSettingStore::NewL( KDomain, KIapId );

    //clean all repository contets

    iSettingsStore->EraseL( 0, 0 );

    iSettings = CNATFWNatSettingsApi::NewL( KDomain );

    }

void UT_CNATFWNatSettings::CRSetupL()

    {

  	SetupL();

  	//Create Domain

  	iSettingsStore->CreateNewDomainL( KDomain );

  	// General settings

  	iSettingsStore->iRefreshIntervalUdp = KUDPRefreshInterval;

    iSettingsStore->iRefreshIntervalTcp = KTCPRefreshInterval;

  	iSettingsStore->iStartPort = KStartPort;

    iSettingsStore->iEndPort = KEndPort;

    iSettingsStore->iCrlfRefresEnabled = KCRLFEnabled;

    iSettingsStore->iUseSharedSecret = KUseSharedSecret;

   	CleanupStack::PushL( iSettingsStore );

  	iSettingsStore->StoreSettingsL();

  	CleanupStack::Pop( iSettingsStore );

	delete iSettings;

	iSettings = NULL;

	iSettings = CNATFWNatSettingsApi::NewL( KDomain );

    }

void UT_CNATFWNatSettings::CRTeardown()

    {

    iSettingsStore->EraseL( 0, 0 );

	Teardown();

    }

void UT_CNATFWNatSettings::Teardown()

    {

    delete iSettings;

    iSettings = NULL;

    iSettingsStore->EraseL( 0, 0 );

    delete iSettingsStore;

    iSettingsStore = NULL;

    }

/***********************************************************************************/

void UT_CNATFWNatSettings::UT_CNATFWNatSettings_NewLL()

    {

    CNATFWNatSettingsApi* settings = NULL;

    settings = CNATFWNatSettingsApi::NewL( KDomain );

    delete settings;

    settings = NULL;

    // create settings with 2 same domain name

    iSettingsStore->CreateNewDomainL( KDomain );

    iSettingsStore->CreateNewDomainL( KDomain );

    NATFW_EUNIT_ASSERT_SPECIFIC_LEAVE(

        settings = CNATFWNatSettingsApi::NewL( KDomain ), KErrCorrupt );

    delete settings;

    settings = NULL;

    // domain is Null pointer

    HBufC8* nullBuf = NULL;

    NATFW_EUNIT_ASSERT_SPECIFIC_LEAVE(

        settings = CNATFWNatSettingsApi::NewL( *nullBuf ), KErrArgument );

    delete settings;

    settings = NULL;

    // domain is empty descriptor

    nullBuf = HBufC8::NewLC( 0 );

    NATFW_EUNIT_ASSERT_SPECIFIC_LEAVE(

        settings = CNATFWNatSettingsApi::NewL( *nullBuf ), KErrArgument );

    delete settings;

    settings = NULL;

    CleanupStack::PopAndDestroy( nullBuf );

    }

void UT_CNATFWNatSettings::UT_CNATFWNatSettings_NewLCL(  )

    {

    CNATFWNatSettingsApi* settings = CNATFWNatSettingsApi::NewLC( KDomain );

    CleanupStack::PopAndDestroy( settings );

    }

void UT_CNATFWNatSettings::UT_CNATFWNatSettings_RetrieveIapSettingsLL(  )

    {

    NATFW_EUNIT_ASSERT_NO_LEAVE(

        iSettings->RetrieveIapSettingsL( KIapId ) );

    // new setings with the same iapid

    NATFW_EUNIT_ASSERT_NO_LEAVE( iSettingsStore->CreateNewIapL( KIapId ) );

    NATFW_EUNIT_ASSERT_SPECIFIC_LEAVE(

        iSettings->RetrieveIapSettingsL( KIapId ), KErrCorrupt );

    }

void UT_CNATFWNatSettings::UT_CNATFWNatSettings_DomainL(  )

    {

    EUNIT_ASSERT_EQUALS( iSettings->Domain(), KDomain );

    }

void UT_CNATFWNatSettings::UT_CNATFWNatSettings_UseSharedSecretL(  )

    {

    iSettingsStore->iUseSharedSecret = ETrue;

    iSettingsStore->StoreSettingsL();    

    delete iSettings;

    iSettings = NULL;

    iSettings = CNATFWNatSettingsApi::NewL( KDomain );

    EUNIT_ASSERT( iSettings->UseSharedSecret() );

    }

void UT_CNATFWNatSettings::UT_CNATFWNatSettings_UDPRefreshIntervalL(  )

    {

    EUNIT_ASSERT_EQUALS( iSettings->RefreshIntervalUdp(),

        KUDPRefreshInterval );

    }

void UT_CNATFWNatSettings::UT_CNATFWNatSettings_TCPRefreshIntervalL(  )

    {

    EUNIT_ASSERT_EQUALS( iSettings->RefreshIntervalTcp(),

        KTCPRefreshInterval );

    }

void UT_CNATFWNatSettings::UT_CNATFWNatSettings_AvailableNatProtocolsL()

    {

    EUNIT_ASSERT( iSettings->AvailableNatProtocols().Count() == 3 );

    EUNIT_ASSERT_EQUALS( iSettings->AvailableNatProtocols().MdcaPoint( 0 ),

        KNokiaStun() );

    EUNIT_ASSERT_EQUALS( iSettings->AvailableNatProtocols().MdcaPoint( 1 ),

        KNokiaTurn() );

    EUNIT_ASSERT_EQUALS( iSettings->AvailableNatProtocols().MdcaPoint( 2 ),

        KNokiaIce() );

    //test with cr contents

    delete iSettingsStore->iAvailableNatProtocols;

    iSettingsStore->iAvailableNatProtocols = NULL;

    iSettingsStore->iAvailableNatProtocols = KNATProtocol().AllocL();

    iSettingsStore->StoreSettingsL();

    delete iSettings;

    iSettings = NULL;

    iSettings = CNATFWNatSettingsApi::NewL( KDomain );

    EUNIT_ASSERT( iSettings->AvailableNatProtocols().Count() == 3 );

    EUNIT_ASSERT_EQUALS( iSettings->AvailableNatProtocols().MdcaPoint( 0 ),

        KNokiaIce() );

    EUNIT_ASSERT_EQUALS( iSettings->AvailableNatProtocols().MdcaPoint( 1 ),

        KNokiaStun() );

    EUNIT_ASSERT_EQUALS( iSettings->AvailableNatProtocols().MdcaPoint( 2 ),

        KNokiaTurn() );

    }

void UT_CNATFWNatSettings::UT_CNATFWNatSettings_GetPortAreaL()

    {

    const TInt KPortPoolStartPort = 45000;

    const TInt KPortPoolEndPort = 50000;

    TUint startPort = 0;

    TUint endPort = 0;

    // write portarea settings to cr

    iSettingsStore->iStartPort = KPortPoolStartPort;

    iSettingsStore->iEndPort = KPortPoolEndPort;

    iSettingsStore->StoreSettingsL();

    delete iSettings;

    iSettings = NULL;

    iSettings = CNATFWNatSettingsApi::NewL( KDomain );

    iSettings->GetPortArea( startPort, endPort );

    EUNIT_ASSERT_EQUALS( startPort, KPortPoolStartPort );

    EUNIT_ASSERT_EQUALS( endPort, KPortPoolEndPort );

    }

void UT_CNATFWNatSettings::UT_CNATFWNatSettings_CrlfRefresEnabledL()

    {

    EUNIT_ASSERT( iSettings->CrlfRefreshEnabled() );

    iSettingsStore->iCrlfRefresEnabled = EFalse;

    iSettingsStore->StoreSettingsL();

    delete iSettings;

    iSettings = NULL;

    iSettings = CNATFWNatSettingsApi::NewL( KDomain );

    EUNIT_ASSERT( !iSettings->CrlfRefreshEnabled() );

    }

void UT_CNATFWNatSettings::UT_CNATFWNatSettings_IceSettingsLL()

    {

    MNATFWIceSettings* iceSettings;

    MNATFWIceSettings* iceSettings2;

    NATFW_EUNIT_ASSERT_NO_LEAVE( iceSettings = &iSettings->IceSettingsL() );

    NATFW_EUNIT_ASSERT_NO_LEAVE( iceSettings2 = &iSettings->IceSettingsL() );

    EUNIT_ASSERT_EQUALS( iceSettings, iceSettings2 );

    }

void UT_CNATFWNatSettings::UT_CNATFWNatSettings_StunSettingsLL()

    {

    MNATFWStunSettings* stunSettings;

    MNATFWStunSettings* stunSettings2;

    NATFW_EUNIT_ASSERT_NO_LEAVE( stunSettings = &iSettings->StunSettingsL() );

    NATFW_EUNIT_ASSERT_NO_LEAVE(

        stunSettings2 = &iSettings->StunSettingsL() );

    EUNIT_ASSERT_EQUALS( stunSettings, stunSettings2 );

    }

void UT_CNATFWNatSettings::UT_CNATFWNatSettings_TurnSettingsLL()

    {

    MNATFWTurnSettings* turnSettings;

    MNATFWTurnSettings* turnSettings2;

    NATFW_EUNIT_ASSERT_NO_LEAVE( turnSettings = &iSettings->TurnSettingsL() );

    NATFW_EUNIT_ASSERT_NO_LEAVE(

        turnSettings2 = &iSettings->TurnSettingsL() );

    EUNIT_ASSERT_EQUALS( turnSettings, turnSettings2 );

    }

//  TEST TABLE

EUNIT_BEGIN_TEST_TABLE(

    UT_CNATFWNatSettings,

    "Add test suite description here.",

    "UNIT" )

EUNIT_TEST(

    "NewL - test ",

    "CNATFWNATSettings",

    "NewL",

    "FUNCTIONALITY",

    CRSetupL, UT_CNATFWNatSettings_NewLL, CRTeardown)

EUNIT_TEST(

    "NewLC - test ",

    "CNATFWNATSettings",

    "NewLC",

    "FUNCTIONALITY",

    SetupL, UT_CNATFWNatSettings_NewLCL, Teardown)

EUNIT_TEST(

    "RetrieveIapSettingsL - test ",

    "CNATFWNATSettings",

    "RetrieveIapSettingsL",

    "FUNCTIONALITY",

    CRSetupL, UT_CNATFWNatSettings_RetrieveIapSettingsLL, CRTeardown)

EUNIT_TEST(

    "Domain - test ",

    "CNATFWNATSettings",

    "Domain",

    "FUNCTIONALITY",

    SetupL, UT_CNATFWNatSettings_DomainL, Teardown)

EUNIT_TEST(

    "UseSharedSecret - test ",

    "CNATFWNATSettings",

    "UseSharedSecret",

    "FUNCTIONALITY",

    CRSetupL, UT_CNATFWNatSettings_UseSharedSecretL, CRTeardown)

EUNIT_TEST(

    "UDPRefreshInterval - test ",

    "CNATFWNATSettings",

    "UDPRefreshInterval",

    "FUNCTIONALITY",

    CRSetupL, UT_CNATFWNatSettings_UDPRefreshIntervalL, CRTeardown)

EUNIT_TEST(

    "TCPRefreshInterval - test ",

    "CNATFWNATSettings",

    "TCPRefreshInterval",

    "FUNCTIONALITY",

    CRSetupL, UT_CNATFWNatSettings_TCPRefreshIntervalL, CRTeardown)

EUNIT_TEST(    

    "GetPortArea - test",

    "CNATFWNATSettings",

    "GetPortArea",

    "FUNCTIONALITY",    

    CRSetupL, UT_CNATFWNatSettings_GetPortAreaL, CRTeardown)

EUNIT_TEST(

    "IceSettingsL - test",

    "CNATFWNATSettings",

    "IceSettingsL",

    "FUNCTIONALITY",    

    SetupL, UT_CNATFWNatSettings_IceSettingsLL, Teardown )

EUNIT_TEST(

    "StunSettingsL - test",

    "CNATFWNATSettings",

    "StunSettingsL",

    "FUNCTIONALITY",    

    SetupL, UT_CNATFWNatSettings_StunSettingsLL, Teardown )

EUNIT_TEST(

    "TurnSettingsL - test",

    "CNATFWNATSettings",

    "TurnSettingsL",

    "FUNCTIONALITY",    

    SetupL, UT_CNATFWNatSettings_TurnSettingsLL, Teardown )

EUNIT_TEST(    

    "AvailableNatProtocols - test",

    "CNATFWNATSettings",

    "AvailableNatProtocols",

    "FUNCTIONALITY",    

    CRSetupL, UT_CNATFWNatSettings_AvailableNatProtocolsL, CRTeardown)

EUNIT_TEST(    

    "CrlfRefresEnabled - test",

    "CNATFWNATSettings",

    "CrlfRefresEnabled",

    "FUNCTIONALITY",    

    CRSetupL, UT_CNATFWNatSettings_CrlfRefresEnabledL, CRTeardown)

EUNIT_END_TEST_TABLE

//  END OF FILE