/*

* Copyright (c) 2005-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:  Source file for EUnit test app for MountMan API

*

*/

// CLASS HEADER

#include "T_RSFW_TA_Basic.h"

// INCLUDES

#include <EUnitMacros.h>

#include <rsfwmountentry.h>

#include <rsfwmountentryitem.h>

#include <f32file.h>

#include <badesca.h>

#include <ecom.h>

#include "rsfwcontrol.h"

#include <s32file.h>

// CONSTRUCTION

T_MountMan* T_MountMan::NewL()

    {

    T_MountMan* self = T_MountMan::NewLC();

    CleanupStack::Pop();

    return self;

    }

T_MountMan* T_MountMan::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor (virtual by CBase)

T_MountMan::~T_MountMan()

    {

    iFs.Close();

    REComSession::FinalClose();  

    }

// Default constructor

T_MountMan::T_MountMan()

    {

    }

// Second phase construct

void T_MountMan::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    iFs.Connect();    

    }

//  METHODS

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

// T_MountMan::SetupL

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

//

void T_MountMan::SetupL(  )

    {

	iMountMan = CRsfwMountMan::NewL(0,NULL);

    }

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

// T_MountMan::Teardown

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

//

void T_MountMan::Teardown(  )

    {

    delete iMountMan;

    iMountMan = NULL;

    }

///////////////////////////////////////////////////////////////////////////////

////// CRsfwMountEntry  ///////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////

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

// T_MountMan::TestSetMountEntryL

// Tests that it is not possible to create an entry with too long attributes

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

//

void T_MountMan::TestSetMountEntryL( )

    {

    TInt err;

    CRsfwMountEntry* mountEntry;

    mountEntry = CRsfwMountEntry::NewLC();

    // too long friendly name

    TBuf<KMaxMountNameLength+1> longName;

    longName.FillZ(longName.MaxLength());

    TRAP(err, mountEntry->SetItemL(EMountEntryItemName, longName));

    EUNIT_ASSERT(err == KErrArgument);

    // too long URI

    TBuf<KMaxMountUriLength+1> longUri;

    longUri.FillZ(longUri.MaxLength());

    TRAP(err, mountEntry->SetItemL(EMountEntryItemUri, longUri));

    EUNIT_ASSERT(err == KErrArgument);

    // too long username

    TBuf<KMaxMountUserNameLength+1> longUserName;

    longUserName.FillZ(longUserName.MaxLength());

    TRAP(err, mountEntry->SetItemL(EMountEntryItemUserName, longUserName));

    EUNIT_ASSERT(err == KErrArgument);

    // too long password

    TBuf<KMaxMountPasswordLength+1> longPassword;

    longPassword.FillZ(longPassword.MaxLength());

    TRAP(err, mountEntry->SetItemL(EMountEntryItemPassword, longPassword));

    EUNIT_ASSERT(err == KErrArgument);

    // too long IAP

    TBuf<KMaxMountConfItemLength+1> longIap;

    longIap.FillZ(longIap.MaxLength());

    TRAP(err, mountEntry->SetItemL(EMountEntryItemIap, longIap));

    EUNIT_ASSERT(err == KErrArgument);

    CleanupStack::PopAndDestroy(mountEntry);

    }

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

// T_MountMan::TestSetItemL

// Tests CRsfwMountEntry::SetItemL(TInt aIndex, const TDesC8& aValue);

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

//

void T_MountMan::TestSetItemL( )

    {

    TInt err;

    CRsfwMountEntry* mountEntry;

    mountEntry = CRsfwMountEntry::NewLC();

    // set entry items one by one

    TRAP(err, mountEntry->SetItemL(EMountEntryItemName, _L8("name")));

    EUNIT_ASSERT(err == KErrNone);

    TRAP(err, mountEntry->SetItemL(EMountEntryItemUri, _L8("http://url")));

    EUNIT_ASSERT(err == KErrNone);

    TRAP(err, mountEntry->SetItemL(EMountEntryItemUserName, _L8("username")));

    EUNIT_ASSERT(err == KErrNone);

    TRAP(err, mountEntry->SetItemL(EMountEntryItemPassword, _L8("password")));

    EUNIT_ASSERT(err == KErrNone);

    TRAP(err, mountEntry->SetItemL(EMountEntryItemIap, _L8("iap")));

    EUNIT_ASSERT(err == KErrNone);

    // check the values

    const HBufC* item = mountEntry->Item(EMountEntryItemName);

    EUNIT_ASSERT((*item).Compare(_L("name")) == KErrNone);

    item = mountEntry->Item(EMountEntryItemUri);

    EUNIT_ASSERT((*item).Compare(_L("http://url")) == KErrNone);

    item = mountEntry->Item(EMountEntryItemUserName);

    EUNIT_ASSERT((*item).Compare(_L("username")) == KErrNone);

    item = mountEntry->Item(EMountEntryItemPassword);

    EUNIT_ASSERT((*item).Compare(_L("password")) == KErrNone);

    item = mountEntry->Item(EMountEntryItemIap);

    EUNIT_ASSERT((*item).Compare(_L("iap")) == KErrNone);

    CleanupStack::PopAndDestroy(mountEntry);

    }

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

// T_MountMan::TestSetItemL

// Tests CRsfwMountEntry::SetItemL(TInt aIndex, const TDesC& aValue);

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

//

void T_MountMan::TestSetItem2L( )

    {

    TInt err;

    CRsfwMountEntry* mountEntry;

    mountEntry = CRsfwMountEntry::NewLC();

    // set entry items one by one

    TRAP(err, mountEntry->SetItemL(EMountEntryItemName, _L("name")));

    EUNIT_ASSERT(err == KErrNone);

    TRAP(err, mountEntry->SetItemL(EMountEntryItemUri, _L("http://url")));

    EUNIT_ASSERT(err == KErrNone);

    TRAP(err, mountEntry->SetItemL(EMountEntryItemUserName, _L("username")));

    EUNIT_ASSERT(err == KErrNone);

    TRAP(err, mountEntry->SetItemL(EMountEntryItemPassword, _L("password")));

    EUNIT_ASSERT(err == KErrNone);

    TRAP(err, mountEntry->SetItemL(EMountEntryItemIap, _L("iap")));

    EUNIT_ASSERT(err == KErrNone);

    // check the values

    const HBufC* item = mountEntry->Item(EMountEntryItemName);

    EUNIT_ASSERT((*item).Compare(_L("name")) == KErrNone);

    item = mountEntry->Item(EMountEntryItemUri);

    EUNIT_ASSERT((*item).Compare(_L("http://url")) == KErrNone);

    item = mountEntry->Item(EMountEntryItemUserName);

    EUNIT_ASSERT((*item).Compare(_L("username")) == KErrNone);

    item = mountEntry->Item(EMountEntryItemPassword);

    EUNIT_ASSERT((*item).Compare(_L("password")) == KErrNone);

    item = mountEntry->Item(EMountEntryItemIap);

    EUNIT_ASSERT((*item).Compare(_L("iap")) == KErrNone);

    CleanupStack::PopAndDestroy(mountEntry);

    }

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

// T_MountMan::TestClearL

// Tests CRsfwMountEntry::Clear

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

//

void T_MountMan::TestClearL( )

    {

    TInt err;

    CRsfwMountEntry* mountEntry;

    mountEntry = CRsfwMountEntry::NewL();

    CleanupStack::PushL(mountEntry);

    // set entry items one by one

    TRAP(err, mountEntry->SetItemL(EMountEntryItemName, _L("name")));

    EUNIT_ASSERT(err == KErrNone);

    TRAP(err, mountEntry->SetItemL(EMountEntryItemUri, _L("http://url")));

    EUNIT_ASSERT(err == KErrNone);

    TRAP(err, mountEntry->SetItemL(EMountEntryItemUserName, _L("username")));

    EUNIT_ASSERT(err == KErrNone);

    TRAP(err, mountEntry->SetItemL(EMountEntryItemPassword, _L("password")));

    EUNIT_ASSERT(err == KErrNone);

    TRAP(err, mountEntry->SetItemL(EMountEntryItemIap, _L("iap")));

    EUNIT_ASSERT(err == KErrNone);

    // clear the values

    mountEntry->Clear();

    // check whether the values are NULL

    const HBufC* item = mountEntry->Item(EMountEntryItemName);

    EUNIT_ASSERT(item == NULL);

    item = mountEntry->Item(EMountEntryItemUri);

    EUNIT_ASSERT(item == NULL);

    item = mountEntry->Item(EMountEntryItemUserName);

    EUNIT_ASSERT(item == NULL);

    item = mountEntry->Item(EMountEntryItemPassword);

    EUNIT_ASSERT(item == NULL);

    item = mountEntry->Item(EMountEntryItemIap);

    EUNIT_ASSERT(item == NULL);

    CleanupStack::PopAndDestroy(mountEntry);

    }

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

// T_MountMan::TestCloneL

// Tests CRsfwMountEntry::Clone

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

//

void T_MountMan::TestCloneL( )

    {

    TInt err;

    CRsfwMountEntry* mountEntry;

    mountEntry = CRsfwMountEntry::NewL();

    CleanupStack::PushL(mountEntry);

    // set entry items one by one

    TRAP(err, mountEntry->SetItemL(EMountEntryItemName, _L("name")));

    EUNIT_ASSERT(err == KErrNone);

    TRAP(err, mountEntry->SetItemL(EMountEntryItemUri, _L("http://url")));

    EUNIT_ASSERT(err == KErrNone);

    TRAP(err, mountEntry->SetItemL(EMountEntryItemUserName, _L("username")));

    EUNIT_ASSERT(err == KErrNone);

    TRAP(err, mountEntry->SetItemL(EMountEntryItemPassword, _L("password")));

    EUNIT_ASSERT(err == KErrNone);

    TRAP(err, mountEntry->SetItemL(EMountEntryItemIap, _L("iap")));

    EUNIT_ASSERT(err == KErrNone);

    // clone the entry

    CRsfwMountEntry* clonedEntry = mountEntry->CloneL();

    CleanupStack::PushL(clonedEntry);

    // check the values in cloned entry

    const HBufC* item = clonedEntry->Item(EMountEntryItemName);

    EUNIT_ASSERT((*item).Compare(_L("name")) == KErrNone);

    item = clonedEntry->Item(EMountEntryItemUri);

    EUNIT_ASSERT((*item).Compare(_L("http://url")) == KErrNone);

    item = clonedEntry->Item(EMountEntryItemUserName);

    EUNIT_ASSERT((*item).Compare(_L("username")) == KErrNone);

    item = clonedEntry->Item(EMountEntryItemPassword);

    EUNIT_ASSERT((*item).Compare(_L("password")) == KErrNone);

    item = clonedEntry->Item(EMountEntryItemIap);

    EUNIT_ASSERT((*item).Compare(_L("iap")) == KErrNone);

    CleanupStack::PopAndDestroy(clonedEntry);

    CleanupStack::PopAndDestroy(mountEntry);

    }

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

// T_MountMan::TestAddMountEntryL

// Tests that it is possible to add 9 mount entries, but not more

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

//

void T_MountMan::TestAddMountEntryL( )

    {

    // be sure no mount entries are in CenRep

    ClearAllMountsL();

    TInt err;    

    err = AddMountEntryL(0, 

                         _L("drivename0"), 

                         DriveToChar(EDriveK),

                         _L("http://url0.com"), 

                         _L("userName0"), 

                         _L("password0"), 

                         _L("iap0"));

    EUNIT_ASSERT(err == KErrNone);

    err = AddMountEntryL(1, 

                         _L("drivename1"), 

                         DriveToChar(EDriveL),

                         _L("http://url1.com"), 

                         _L("userName1"), 

                         _L("password1"), 

                         _L("iap1"));

    EUNIT_ASSERT(err == KErrNone);

    err = AddMountEntryL(2, 

                         _L("drivename2"), 

                         DriveToChar(EDriveM),

                         _L("http://url2.com"), 

                         _L("userName2"), 

                         _L("password2"), 

                         _L("iap2"));

    EUNIT_ASSERT(err == KErrNone);    

    err = AddMountEntryL(3, 

                         _L("drivename3"), 

                         DriveToChar(EDriveN),

                         _L("http://url3.com"), 

                         _L("userName3"), 

                         _L("password3"), 

                         _L("iap3"));

    EUNIT_ASSERT(err == KErrNone);    

    err = AddMountEntryL(4, 

                         _L("drivename4"), 

                         DriveToChar(EDriveO),

                         _L("http://url4.com"), 

                         _L("userName4"), 

                         _L("password4"), 

                         _L("iap4"));

    EUNIT_ASSERT(err == KErrNone);    

    err = AddMountEntryL(5, 

                         _L("drivename5"), 

                         DriveToChar(EDriveP),

                         _L("http://url5.com"), 

                         _L("userName5"), 

                         _L("password5"), 

                         _L("iap5"));

    EUNIT_ASSERT(err == KErrNone);	

    err = AddMountEntryL(6, 

                         _L("drivename6"), 

                         DriveToChar(EDriveQ),

                         _L("http://url6.com"), 

                         _L("userName6"), 

                         _L("password6"), 

                         _L("iap6"));

    EUNIT_ASSERT(err == KErrNone);	    

    err = AddMountEntryL(7, 

                         _L("drivename7"), 

                         DriveToChar(EDriveR),

                         _L("http://url7.com"), 

                         _L("userName7"), 

                         _L("password7"), 

                         _L("iap7"));

    EUNIT_ASSERT(err == KErrNone);	    

    err = AddMountEntryL(8, 

                         _L("drivename8"), 

                         DriveToChar(EDriveS),

                         _L("http://url8.com"), 

                         _L("userName8"), 

                         _L("password8"), 

                         _L("iap8"));

    EUNIT_ASSERT(err == KErrNone);	   

    // 10th drive should not pass! 

    err = AddMountEntryL(9, 

                         _L("drivename9"), 

                         DriveToChar(EDriveT),

                         _L("http://url9.com"), 

                         _L("userName9"), 

                         _L("password9"), 

                         _L("iap9"));

    EUNIT_ASSERT(err == KErrInUse);	    

    }

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

// T_MountMan::TestAddMountEntry2L

// Tests that it is not possible to add two entries with the same name

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

//

void T_MountMan::TestAddMountEntry2L( )

    {

    // be sure no mount entries are in CenRep

    ClearAllMountsL();

    TInt err;

    err = AddMountEntryL(0, 

                         _L("thesamename"), 

                         DriveToChar(EDriveK),

                         _L("http://url0.com"), 

                         _L("userName0"), 

                         _L("password0"), 

                         _L("iap0"));

    EUNIT_ASSERT(err == KErrNone);

    err = AddMountEntryL(1, 

                         _L("thesamename"), 

                         DriveToChar(EDriveL),

                         _L("http://url1.com"), 

                         _L("userName1"), 

                         _L("password1"), 

                         _L("iap1"));

    EUNIT_ASSERT(err == KErrInUse);

    }

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

// T_MountMan::TestAddMountEntry3L

// Tests that it is not possible to add two entries with the same drive letter

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

//

void T_MountMan::TestAddMountEntry3L( )

    {

    // be sure no mount entries are in CenRep

    ClearAllMountsL();

    TInt err;

    err = AddMountEntryL(0, 

                         _L("drivename0"), 

                         DriveToChar(EDriveK),

                         _L("http://url0.com"), 

                         _L("userName0"), 

                         _L("password0"), 

                         _L("iap0"));

    EUNIT_ASSERT(err == KErrNone);

    err = AddMountEntryL(1, 

                         _L("drivename1"), 

                         DriveToChar(EDriveK),

                         _L("http://url1.com"), 

                         _L("userName1"), 

                         _L("password1"), 

                         _L("iap1"));

    EUNIT_ASSERT(err == KErrInUse);

    }

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

// T_MountMan::TestEditMountEntryL

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

//

void T_MountMan::TestEditMountEntryL( )

    {

    // be sure no mount entries are in CenRep

    ClearAllMountsL(); 

    TInt err;    

    err = AddMountEntryL(0, 

                         _L("drivename0"), 

                         DriveToChar(EDriveK),

                         _L("http://url0.com"), 

                         _L("userName0"), 

                         _L("password0"), 

                         _L("iap0"));

    EUNIT_ASSERT(err == KErrNone);

    err = EditMountEntryL(0, 

                         _L("differentName"), 

                         DriveToChar(EDriveK),

                         _L("http://different.com"), 

                         _L("differentUserName"), 

                         _L("differentPassword"), 

                         _L("differentIap"));

    EUNIT_ASSERT(err == KErrNone);

    const CRsfwMountEntry* entry = NULL;

    TRAP (err, entry = iMountMan->MountEntryL(DriveToChar(EDriveK)));

    EUNIT_ASSERT(err == KErrNone);

    err = CheckEntryL(entry,

                      0, 

                      _L("differentName"), 

                      DriveToChar(EDriveK),

                      _L("http://different.com"), 

                      _L("differentUserName"), 

                      _L("differentPassword"), 

                      _L("differentIap"));

    EUNIT_ASSERT(err == KErrNone);

    }

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

// T_MountMan::TestEditMountEntry2L

// tests that nonexising mount cannot be edited

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

//

void T_MountMan::TestEditMountEntry2L( )

    {

    // be sure no mount entries are in CenRep

    ClearAllMountsL();

    TInt err;

    // try to edit nonexisting mount

    err = EditMountEntryL(0, 

                         _L("drivename0"), 

                         DriveToChar(EDriveK),

                         _L("http://url1.com"), 

                         _L("userName0"), 

                         _L("password0"), 

                         _L("iap0"));

    EUNIT_ASSERT(err == KErrNotFound);    

    }

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

// T_MountMan::TestEditMountEntry3L

// tests that it is not allowed to change the name into the one

// that is already in use

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

//

void T_MountMan::TestEditMountEntry3L( )