// Copyright (c) 2007-2009 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:

//

#include "tineturilisttests.h"

#include <cauthentication.h>

#include "testutils.h"

#define __LEAVEIFOOM__ if ( err == KErrNoMemory ) \

				User::Leave ( err );

#define __PRINTIFNOTOOM__ if ( iNormalRun )

CInetUriListTestsBase::CInetUriListTestsBase ( CTestWrapper& aTestWrapper, TBool aNormalRun )

: iTestWrapper ( aTestWrapper ),

iNormalRun ( aNormalRun )

	{

	}

CInetUriListTestsBase::~CInetUriListTestsBase ()

	{

	iInetUriList.Close ();		

	}

void CInetUriListTestsBase::ConstructL ()

	{

	iInetUriList.OpenL ();

	}

RInetUri CInetUriListTestsBase::CreateNewUriL ( const TDesC8& aUri, TServiceType aServiceType, TListType aListType )

	{

	RInetUri myInetUri;

	CleanupClosePushL ( myInetUri );

	myInetUri.CreateL ( aUri, aServiceType, aListType );

	CleanupStack::Pop (); // myInetUri 

	return myInetUri;			

	}

void CInetUriListTestsBase::RunTestsL ()

	{

	if ( iNormalRun )

		{

		DoCleanupL ();

		DoOperationL ();		

		}		

	else

		{

		TInt ret = KErrNoMemory;

		TInt failAt = 0;

		while( ret != KErrNone )

			{

			DoCleanupL ();

			failAt++;

   			iTestWrapper.Tester().Printf( _L( "Test step: %d\n" ), failAt );					

			__UHEAP_RESET;

			__UHEAP_SETFAIL( RHeap::EDeterministic, failAt );

			TInt countBefore = User::CountAllocCells();			

			TRAP ( ret, DoOperationL () );

			TInt countAfter = User::CountAllocCells();					

			__UHEAP_RESET;	

			if ( countBefore != countAfter )

				{

				iTestWrapper.Tester().Printf ( _L ("OOM test failed at iteration %d"), failAt );

				break;

				}

			}	

		iTestWrapper.Tester().Printf ( _L ("OOM test has been successfully completed. Total iterations: %d"), failAt );							

		}

	}

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

CInetUriListStorageTests* CInetUriListStorageTests::NewL ( CTestWrapper& aTestWrapper, TBool aNormalRun )

	{

	CInetUriListStorageTests* self  = new ( ELeave )CInetUriListStorageTests ( aTestWrapper, aNormalRun );

	CleanupStack::PushL ( self );

	self->ConstructL ();

	CleanupStack::Pop ();

	return self;

	}

CInetUriListStorageTests::~CInetUriListStorageTests ()

	{

	}

CInetUriListStorageTests::CInetUriListStorageTests ( CTestWrapper& aTestWrapper, TBool aNormalRun )

: CInetUriListTestsBase ( aTestWrapper, aNormalRun )

	{

	}

void CInetUriListStorageTests::DoOperationL ()

	{

	iTestWrapper.SetFile ( _L ("tineturilisttests.cpp") );

	AddTestsL ();

	GetListTypeL ();

	UpdateTestsL ();		

	RemoveTestsL ();

	SameUriDiffServiceTypeTestsL ();

	AddFewMoreUrisL ();

	}

void CInetUriListStorageTests::DoCleanupL ()

	{

	CInetUriListCleanup* listCleanup = CInetUriListCleanup::NewL (iTestWrapper);

	CleanupStack::PushL ( listCleanup );

	listCleanup->DoOperationL ();

	CleanupStack::PopAndDestroy (); // listCleanup		

	}

void CInetUriListStorageTests::AddTestsL ()

	{

	__PRINTIFNOTOOM__

	iTestWrapper.Next ( _L ( "URI add tests" ) );

	// Create a new uri

	RInetUri myInetUri = CreateNewUriL ( KTestUri(), InetUriList::EWapPush, InetUriList::EWhiteList );

	CleanupClosePushL ( myInetUri );

	myInetUri.SetFavouriteNameL ( KUriFavouriteName() );

	// Add the uri

	TRAPD ( err, iInetUriList.AddL ( myInetUri ) );

	__LEAVEIFOOM__	

	iTestWrapper.TESTE( err==KErrNone, err );

	// Create another uri

	RInetUri myInetUri2 = CreateNewUriL ( KTestUri2(), InetUriList::EWapPush, InetUriList::EWhiteList );

	CleanupClosePushL ( myInetUri2 );

	// Add the uri

	TRAP ( err, iInetUriList.AddL ( myInetUri2 ) );

	__LEAVEIFOOM__

	iTestWrapper.TESTE( err==KErrNone, err );

	TRAP ( err, iInetUriList.AddL ( myInetUri ) );

	__LEAVEIFOOM__

	iTestWrapper.TESTE( err==InetUriList::KErrUriAlreadyExists, err );

	// Create another uri

	RInetUri myInetUri3 = CreateNewUriL ( KTestUri3(), InetUriList::EWapPush, InetUriList::EBlackList );

	CleanupClosePushL ( myInetUri3 );

	// Add the uri

	TRAP ( err, iInetUriList.AddL ( myInetUri3 ) );

	__LEAVEIFOOM__

	iTestWrapper.TESTE( err==KErrNone, err );

	TInt count = iInetUriList.Count ( InetUriList::EWapPush, InetUriList::EWhiteList );

	// 2 URI has been added

	iTestWrapper.TEST( count == 2 );

	CleanupStack::PopAndDestroy (3); // inetUri, inetUri2, inetUri3

	count = iInetUriList.Count ( InetUriList::EWapPush, InetUriList::EWhiteList );

	// 2 URI has been added

	iTestWrapper.TEST( count == 2 );

	count = iInetUriList.Count ( InetUriList::EWapPush, InetUriList::EBlackList );

	// 2 URI has been added

	iTestWrapper.TEST( count == 1 );

	}

void CInetUriListStorageTests::RemoveTestsL ()

	{

	__PRINTIFNOTOOM__

	iTestWrapper.Next ( _L ( "URI remove test" ) );			

	RInetUri myInetUri = iInetUriList.OpenInetUriL ( KTestUri2(), InetUriList::EWapPush );

	CleanupClosePushL ( myInetUri );

	TRAPD ( err, iInetUriList.RemoveL ( myInetUri ) );

	__LEAVEIFOOM__

	iTestWrapper.TEST ( err == KErrNone );

	// Try to update. Must return KErrNotFound

	TRAP ( err, iInetUriList.UpdateL ( myInetUri ) );

	__LEAVEIFOOM__

	iTestWrapper.TEST ( err == InetUriList::KErrUriNotFound );

	CleanupStack::PopAndDestroy ( &myInetUri );	

	// Open the same URI

	TRAP ( err, myInetUri = iInetUriList.OpenInetUriL ( KTestUri2(), InetUriList::EWapPush ) );		

	__LEAVEIFOOM__

	iTestWrapper.TEST ( err == InetUriList::KErrUriNotFound );

	// Now we are having only 1 URI in whitelist and blacklist

	TInt count = iInetUriList.Count ( InetUriList::EWapPush, InetUriList::EWhiteList );

	// 1 URI has been added

	iTestWrapper.TEST( count == 1 );

	count = iInetUriList.Count ( InetUriList::EWapPush, InetUriList::EBlackList );

	// 1 URI has been added

	iTestWrapper.TEST( count == 1 );		

	}

void CInetUriListStorageTests::UpdateTestsL ()

	{

	__PRINTIFNOTOOM__

	iTestWrapper.Next ( _L ( "URI update test" ) );		

	RInetUri myInetUri = iInetUriList.OpenInetUriL ( KTestUri2(), InetUriList::EWapPush );

	CleanupClosePushL ( myInetUri );

	// Update list type

	myInetUri.SetListType ( InetUriList::EBlackList );

	TRAPD ( err, iInetUriList.UpdateL ( myInetUri ) );

	__LEAVEIFOOM__

	iTestWrapper.TESTE( err==KErrNone, err );

	CleanupStack::PopAndDestroy (&myInetUri); // myInetUri

	// Check list type is updated proeprly

	myInetUri = iInetUriList.OpenInetUriL ( KTestUri2(), InetUriList::EWapPush );

	CleanupClosePushL ( myInetUri );	

	iTestWrapper.TEST ( myInetUri.ListType() == InetUriList::EBlackList );

	// Update favourite name

	myInetUri.SetFavouriteNameL ( KUriFavouriteName2() );

	TRAP ( err, iInetUriList.UpdateL ( myInetUri ) );

	__LEAVEIFOOM__

	iTestWrapper.TESTE( err==KErrNone, err );

	CleanupStack::PopAndDestroy (); // myInetUri

	// Open again and see favourite name is updated properly

	myInetUri = iInetUriList.OpenInetUriL ( KTestUri2(), InetUriList::EWapPush );

	CleanupClosePushL ( myInetUri );	

	iTestWrapper.TEST ( myInetUri.FavouriteName().Compare ( KUriFavouriteName2() ) == 0 );

	CleanupStack::PopAndDestroy (); // myInetUri

	// Now we are having 1 URI in whitelist and 2 URI in blacklist

	TInt count = iInetUriList.Count ( InetUriList::EWapPush, InetUriList::EWhiteList );

	// 2 URI has been added

	iTestWrapper.TEST( count == 1 );

	count = iInetUriList.Count ( InetUriList::EWapPush, InetUriList::EBlackList );

	// 2 URI has been added

	iTestWrapper.TEST( count == 2 );

	}

void CInetUriListStorageTests::GetListTypeL ()

	{

	__PRINTIFNOTOOM__

	iTestWrapper.Next ( _L ( "Retrieve URI list type" ) );	

	InetUriList::TListType listType;

	TInt err = iInetUriList.GetListType ( KTestUri(), InetUriList::EWapPush, listType );

	__LEAVEIFOOM__

	iTestWrapper.TEST ( err == KErrNone );

	iTestWrapper.TEST ( listType == InetUriList::EWhiteList );

	err = iInetUriList.GetListType ( KTestUri3(), InetUriList::EWapPush, listType );

	__LEAVEIFOOM__

	iTestWrapper.TEST ( err == KErrNone );

	iTestWrapper.TEST ( listType == InetUriList::EBlackList );

	err = iInetUriList.GetListType ( KUnknownUri(), InetUriList::EWapPush, listType );

	__LEAVEIFOOM__

	iTestWrapper.TEST ( err == InetUriList::KErrUriNotFound );

	// Open an invalid URI

	RInetUri myInetUri;

	TRAP ( err, myInetUri = iInetUriList.OpenInetUriL ( KUnknownUri(), EWapPush ) );

	__LEAVEIFOOM__

	iTestWrapper.TEST ( err == InetUriList::KErrUriNotFound );

	}

void CInetUriListStorageTests::SameUriDiffServiceTypeTestsL ()

	{

	RInetUri myInetUri = CreateNewUriL ( KTestUri4(), InetUriList::EWapPush, InetUriList::EWhiteList );

	CleanupClosePushL ( myInetUri );

	RInetUri myInetUri2 = CreateNewUriL ( KTestUri4(), InetUriList::EBrowser, InetUriList::EWhiteList );

	CleanupClosePushL ( myInetUri2 );

	// Add the 2 URIs

	TRAPD ( err, iInetUriList.AddL ( myInetUri ) );

	__LEAVEIFOOM__

	iTestWrapper.TEST ( err == KErrNone );

	TRAP ( err, iInetUriList.AddL ( myInetUri2 ) );

	__LEAVEIFOOM__

	iTestWrapper.TEST ( err == KErrNone );

	CleanupStack::PopAndDestroy (2); // myInetUri, myInetUri2

	// Now open the URI

	TRAP ( err, myInetUri = iInetUriList.OpenInetUriL ( KTestUri4(), InetUriList::EWapPush ) );

	__LEAVEIFOOM__

	iTestWrapper.TEST ( err == KErrNone );

	CleanupClosePushL ( myInetUri );

	// Remove the URI

	TRAP ( err, iInetUriList.RemoveL ( myInetUri ) );

	__LEAVEIFOOM__

	iTestWrapper.TEST ( err == KErrNone );

	CleanupStack::PopAndDestroy ( &myInetUri );

	TRAP ( err, myInetUri = iInetUriList.OpenInetUriL ( KTestUri4(), InetUriList::EWapPush ) );	

	__LEAVEIFOOM__

	iTestWrapper.TEST ( err == InetUriList::KErrUriNotFound );

	TRAP ( err, myInetUri = iInetUriList.OpenInetUriL ( KTestUri4(), InetUriList::EBrowser ) );	

	__LEAVEIFOOM__

	iTestWrapper.TEST ( err == KErrNone );

	myInetUri.Close ();

	// Now we are having 1 URI in Browser Service Type in whitelist

	TInt count = iInetUriList.Count ( InetUriList::EBrowser, InetUriList::EWhiteList );

	// 1 URI has been added

	iTestWrapper.TEST( count == 1 );

	// Add few more URIs in Browser service type 1 in BL and 1 in WL

	myInetUri = CreateNewUriL ( KTestUri5(), InetUriList::EBrowser, InetUriList::EBlackList );

	CleanupClosePushL ( myInetUri );

	myInetUri2 = CreateNewUriL ( KTestUri6(), InetUriList::EBrowser, InetUriList::EWhiteList );

	CleanupClosePushL ( myInetUri2 );

	myInetUri2.SetFavouriteNameL ( KUriFavouriteName3() );

	TRAP ( err, iInetUriList.AddL ( myInetUri ) );

	__LEAVEIFOOM__

	iTestWrapper.TEST ( err == KErrNone );

	TRAP ( err, iInetUriList.AddL ( myInetUri2 ) );

	__LEAVEIFOOM__

	iTestWrapper.TEST ( err == KErrNone );

	CleanupStack::PopAndDestroy ( 2 ); // myInetUri, myInetUri2			

	}

void CInetUriListStorageTests::AddFewMoreUrisL ()

	{

	RInetUri myInetUri = CreateNewUriL ( KTestUri7(), EBrowser, EWhiteList );

	CleanupClosePushL ( myInetUri );

	RInetUri myInetUri2 = CreateNewUriL ( KTestUri8(), EBrowser, EWhiteList );

	CleanupClosePushL ( myInetUri2 );

	RInetUri myInetUri3 = CreateNewUriL ( KTestUri9(), EBrowser, EBlackList );

	CleanupClosePushL ( myInetUri3 );

	RInetUri myInetUri4 = CreateNewUriL ( KTestUri10(), EBrowser, EBlackList );

	CleanupClosePushL ( myInetUri4 );

	RInetUri myInetUri5 = CreateNewUriL ( KTestUri11(), EBrowser, EBlackList );

	CleanupClosePushL ( myInetUri5 );

	TRAPD ( err, iInetUriList.AddL ( myInetUri ) );

	__LEAVEIFOOM__

	iTestWrapper.TEST ( err == KErrNone );

	TRAP ( err, iInetUriList.AddL ( myInetUri2 ) );

	__LEAVEIFOOM__

	iTestWrapper.TEST ( err == KErrNone );

	TRAP ( err, iInetUriList.AddL ( myInetUri3 ) );

	__LEAVEIFOOM__

	iTestWrapper.TEST ( err == KErrNone );

	TRAP ( err, iInetUriList.AddL ( myInetUri4 ) );

	__LEAVEIFOOM__

	iTestWrapper.TEST ( err == KErrNone );

	TRAP ( err, iInetUriList.AddL ( myInetUri5 ) );

	__LEAVEIFOOM__

	iTestWrapper.TEST ( err == KErrNone );

	CleanupStack::PopAndDestroy (5); // myInetUri ... myInetUri4	

	}

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

CInetUriListQuery* CInetUriListQuery::NewLC ( CTestWrapper& aTest, TBool aNormalRun )

	{

	CInetUriListQuery* self = new (ELeave)CInetUriListQuery ( aTest, aNormalRun );

	CleanupStack::PushL ( self );

	self->ConstructL ();

	return self;

	}

CInetUriListQuery::CInetUriListQuery ( CTestWrapper& aTest, TBool aNormalRun )

: CInetUriListTestsBase ( aTest, aNormalRun )

	{

	}

CInetUriListQuery::~CInetUriListQuery ()

	{

	Cleanup ();

	}

void CInetUriListQuery::DoOperationL ()

	{

	TRAPD ( err, QueryListL() );

	Cleanup ();

	User::LeaveIfError ( err );

	TRAPD ( tlderr, QueryTldListL());

	User::LeaveIfError ( tlderr );

	}

void CInetUriListQuery::QueryListL ()

	{	

	__PRINTIFNOTOOM__

	iTestWrapper.Next ( _L ( "Query URIs with ServiceType & ListType - Browser & Whitelist") );

	// Generate the expected URIs for this query

	AppendExpectedUriL ( KTestUri4(), EBrowser );

	AppendExpectedUriL ( KTestUri6(), EBrowser );

	AppendExpectedUriL ( KTestUri7(), EBrowser );

	AppendExpectedUriL ( KTestUri8(), EBrowser );	

	TQueryArgs args ( InetUriList::EBrowser, InetUriList::EWhiteList );	

	DoQueryL ( args );

	__PRINTIFNOTOOM__

	iTestWrapper.Next ( _L ( "Query URIs with ServiceType & ListType - Browser & Blacklist") );	

	AppendExpectedUriL ( KTestUri5(), EBrowser );

	AppendExpectedUriL ( KTestUri9(), EBrowser );

	AppendExpectedUriL ( KTestUri10(), EBrowser );

	AppendExpectedUriL ( KTestUri11(), EBrowser );			

	TQueryArgs args2 ( InetUriList::EBrowser, InetUriList::EBlackList );	

	DoQueryL ( args2 );

	// Do query operation with exact path match and a list type

	__PRINTIFNOTOOM__

	iTestWrapper.Next ( _L ( "Query URIs with exact path match & ListType") );		

	AppendExpectedUriL ( KTestUri6(), EBrowser );

	const TPtrC8 uri ( KTestUri6() );

	TQueryArgs args3 ( &uri, EBrowser, EWhiteList, EExactPath );

	DoQueryL ( args3 );

	// Do query operation with partial suffix path match and a list type

	__PRINTIFNOTOOM__

	iTestWrapper.Next ( _L ( "Query URIs with partial suffix path match & ListType") );		

	const TPtrC8 uri2 ( KPartialPathSuffixUri() );

	AppendExpectedUriL ( KTestUri4(), EBrowser );

	AppendExpectedUriL ( KTestUri6(), EBrowser );

	TQueryArgs args4 ( &uri2, EBrowser, EWhiteList, EPartialSuffixPath );

	DoQueryL ( args4 );

	// Do query operation with partial prefix path match and a list type

	__PRINTIFNOTOOM__

	iTestWrapper.Next ( _L ( "Query URIs with partial prefix path match & ListType") );	

	AppendExpectedUriL ( KTestUri5(), EBrowser );

	const TPtrC8 uri3 ( KPartialPathPrefixUri() );

	TQueryArgs args5 ( &uri3, EBrowser, EBlackList, EPartialPrefixPath );

	DoQueryL ( args5 );

	// Do query operation with partial suffix path match and without a list type

	__PRINTIFNOTOOM__

	iTestWrapper.Next ( _L ( "Query URIs with partial suffix path match & without ListType") );	

	AppendExpectedUriL ( KTestUri4(), EBrowser );

	AppendExpectedUriL ( KTestUri5(), EBrowser );	

	AppendExpectedUriL ( KTestUri6(), EBrowser );	

	const TPtrC8 uri4 ( KPartialPathSuffixUri() );

	TQueryArgs args6 ( &uri4, EBrowser, EPartialSuffixPath );

	DoQueryL ( args6 );

	// Do query operation with partial prefix path match and without a list type

	__PRINTIFNOTOOM__

	iTestWrapper.Next ( _L ( "Query URIs with partial prefix path match & without ListType") );		

	AppendExpectedUriL ( KTestUri5(), EBrowser );

	const TPtrC8 uri5 ( KPartialPathPrefixUri() );

	TQueryArgs args7 ( &uri5, EBrowser, EPartialPrefixPath );

	DoQueryL ( args7 );

	// Do a domain search with List type - 2 in whitelist & 3 in blacklist for mydomain.com

	// Domain search with servicetype & listtype ( Browser & Whitelist )

	__PRINTIFNOTOOM__

	iTestWrapper.Next ( _L ( "Query URIs with domain match with ListType - WhiteList") );

	const TPtrC8 uri6 ( KDomainSearchStr() );

	AppendExpectedUriL ( KTestUri7(), EBrowser );

	AppendExpectedUriL ( KTestUri8(), EBrowser );	

	TQueryArgs args8 ( &uri6, EBrowser, EWhiteList, EDomain );

	DoQueryL ( args8 );	

	__PRINTIFNOTOOM__

	iTestWrapper.Next ( _L ( "Query URIs with domain match with ListType - BlackList") );	

	const TPtrC8 uri7 ( KDomainSearchStr() );	

	AppendExpectedUriL ( KTestUri9(), EBrowser );

	AppendExpectedUriL ( KTestUri10(), EBrowser );	

	AppendExpectedUriL ( KTestUri11(), EBrowser );		

	TQueryArgs args9 ( &uri7, EBrowser, EBlackList, EDomain );

	DoQueryL ( args9 );	

	__PRINTIFNOTOOM__

	iTestWrapper.Next ( _L ( "Query URIs with domain match with no ListType") );		

	const TPtrC8 uri8 ( KDomainSearchStr() );		

	AppendExpectedUriL ( KTestUri7(), EBrowser );

	AppendExpectedUriL ( KTestUri8(), EBrowser );	

	AppendExpectedUriL ( KTestUri9(), EBrowser );

	AppendExpectedUriL ( KTestUri10(), EBrowser );	

	AppendExpectedUriL ( KTestUri11(), EBrowser );		

	TQueryArgs args10 ( &uri8, EBrowser, EDomain );

	DoQueryL ( args10 );	

	}

void CInetUriListQuery::DoQueryL ( TQueryArgs aArgs )

	{

	iInetUriList.QueryUriL ( aArgs, this );

	MatchQueryResults	();

	Cleanup	();

	}

void CInetUriListQuery::QueryTldListL()

	{

	DoQueryPolicyL();

	DoQueryListL();

	}

void CInetUriListQuery::DoQueryPolicyL()

	{

	__PRINTIFNOTOOM__

	iTestWrapper.Next ( _L ( "Query TLD URIs with Uri, ListType and TldQueryType -- Fetch WhiteList data") );

	const TPtrC8 tlduri1 ( KTldTestUri1() );

	TPolicyQueryArgs queryArg1( &tlduri1, EWhiteList, EPolicyCharSet);

	TQueryResults PolicyDataArg1;

	DoQueryPolcydataL(queryArg1, PolicyDataArg1);

		__PRINTIFNOTOOM__

	iTestWrapper.Next ( _L ( "Query TLD URIs with Uri, ListType and TldQueryType -- Fetch BlackList data") );

	const TPtrC8 tlduri2 ( KTldTestUri2() );

	TPolicyQueryArgs queryArg2( &tlduri2, EBlackList, EPolicyCharSet);

	TQueryResults PolicyDataArg2;

	DoQueryPolcydataL(queryArg2, PolicyDataArg2);

		__PRINTIFNOTOOM__

	iTestWrapper.Next ( _L ( "Query TLD URIs with Uri, ListType and TldQueryType -- Fetch WhiteList data") );

	const TPtrC8 tlduri3 ( KTldTestUri3() );

	TPolicyQueryArgs queryArg3( &tlduri3, EWhiteList, EPolicyCharSet);

	TQueryResults PolicyDataArg3;

	DoQueryPolcydataL(queryArg3, PolicyDataArg3);

		__PRINTIFNOTOOM__