--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/applayerpluginsandutils/uripermissionservices/Test/tineturilisttests.cpp	Tue Feb 02 01:09:52 2010 +0200
@@ -0,0 +1,795 @@
+// 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__
+	iTestWrapper.Next ( _L ( "Query TLD URIs with Uri, ListType and TldQueryType -- Fetch BlackList data") );
+	const TPtrC8 tlduri4 ( KTldTestUri4() );
+	TPolicyQueryArgs queryArg4( &tlduri4, EBlackList, EPolicyCharSet);
+	TQueryResults PolicyDataArg4;
+	DoQueryPolcydataL(queryArg4, PolicyDataArg4);
+	
+		__PRINTIFNOTOOM__
+	iTestWrapper.Next ( _L ( "Query TLD URIs with Uri, ListType and TldQueryType -- Fetch WhiteList data") );
+	const TPtrC8 tlduri5 ( KTldTestUri5() );
+	TPolicyQueryArgs queryArg5( &tlduri5, EWhiteList, EPolicyCharSet);
+	TQueryResults PolicyDataArg5;
+	DoQueryPolcydataL(queryArg5, PolicyDataArg5);
+	
+		__PRINTIFNOTOOM__
+	iTestWrapper.Next ( _L ( "Query TLD URIs with Uri, ListType and TldQueryType -- Fetch BlackList data") );
+	const TPtrC8 tlduri6 ( KTldTestUri6() );
+	TPolicyQueryArgs queryArg6( &tlduri6, EBlackList, EPolicyCharSet);
+	TQueryResults PolicyDataArg6;
+	DoQueryPolcydataL(queryArg6, PolicyDataArg6);
+	
+		__PRINTIFNOTOOM__
+	iTestWrapper.Next ( _L ( "Query TLD URIs with Uri, ListType and TldQueryType -- Fetch WhiteList data") );
+	const TPtrC8 tlduri7 ( KTldTestUri7() );
+	TPolicyQueryArgs queryArg7( &tlduri7, EWhiteList, EPolicyCharSet);
+	TQueryResults PolicyDataArg7;
+	DoQueryPolcydataL(queryArg7, PolicyDataArg7);
+	
+		__PRINTIFNOTOOM__
+	iTestWrapper.Next ( _L ( "Query TLD URIs with Uri, ListType and TldQueryType -- Fetch BlackList data") );
+	const TPtrC8 tlduri8 ( KTldTestUri7() );
+	TPolicyQueryArgs queryArg8( &tlduri8, EBlackList, EPolicyCharSet);
+	TQueryResults PolicyDataArg8;
+	DoQueryPolcydataL(queryArg8, PolicyDataArg8);
+	
+		__PRINTIFNOTOOM__
+	iTestWrapper.Next ( _L ( "Query TLD URIs with Uri, ListType and TldQueryType -- Fetch WhiteList data") );
+	const TPtrC8 tlduri9 ( KTldTestUri8() );
+	TPolicyQueryArgs queryArg9( &tlduri9, EWhiteList, EPolicyCharSet);
+	TQueryResults PolicyDataArg9;
+	DoQueryPolcydataL(queryArg9, PolicyDataArg9);
+	
+		__PRINTIFNOTOOM__
+	iTestWrapper.Next ( _L ( "Query TLD URIs with Uri, ListType and TldQueryType -- Fetch BlackList data") );
+	const TPtrC8 tlduri10 ( KTldTestUri8() );
+	TPolicyQueryArgs queryArg10( &tlduri10, EBlackList, EPolicyCharSet);
+	TQueryResults PolicyDataArg10;
+	DoQueryPolcydataL(queryArg10, PolicyDataArg10);
+
+	//Negative tests
+	
+		__PRINTIFNOTOOM__
+	iTestWrapper.Next ( _L ( "Query TLD URIs without Uri -- Negative test") );
+	TPolicyQueryArgs queryArg11( EBlackList, EPolicyCharSet);
+	TQueryResults PolicyDataArg11;
+	DoQueryPolcydataL(queryArg11, PolicyDataArg11);
+	
+	__PRINTIFNOTOOM__
+	iTestWrapper.Next ( _L ( "Query TLD URIs without List Type and TldQueryType -- Negative test") );
+	const TPtrC8 tlduri12 ( KTldTestUri8() );
+	TPolicyQueryArgs queryArg12( &tlduri12 );
+	TQueryResults PolicyDataArg12;
+	DoQueryPolcydataL(queryArg12, PolicyDataArg12);
+	
+	__PRINTIFNOTOOM__
+	iTestWrapper.Next ( _L ( "Query TLD URIs without URI & List Type  -- Negative test") );
+	TPolicyQueryArgs queryArg13( EPolicyCharSet );
+	TQueryResults PolicyDataArg13;
+	DoQueryPolcydataL(queryArg13, PolicyDataArg13);
+	
+		__PRINTIFNOTOOM__
+	iTestWrapper.Next ( _L ( "Query TLD URIs without URI & TldQueryType -- Negative test") );
+	TPolicyQueryArgs queryArg14( EBlackList );
+	TQueryResults PolicyDataArg14;
+	DoQueryPolcydataL(queryArg14, PolicyDataArg14);
+	
+	__PRINTIFNOTOOM__
+	iTestWrapper.Next ( _L ( "Query TLD URIs without TldQueryType -- Negative test") );
+	const TPtrC8 tlduri15 ( KTldTestUri8() );
+	TPolicyQueryArgs queryArg15( &tlduri15, EBlackList );
+	TQueryResults PolicyDataArg15;
+	DoQueryPolcydataL(queryArg15, PolicyDataArg15);
+	
+		__PRINTIFNOTOOM__
+	iTestWrapper.Next ( _L ( "Query TLD URIs without ListType -- Negative test") );
+	const TPtrC8 tlduri16 ( KTldTestUri8() );
+	TPolicyQueryArgs queryArg16( &tlduri16, EPolicyCharSet );
+	TQueryResults PolicyDataArg16;
+	DoQueryPolcydataL(queryArg16, PolicyDataArg16);
+	}
+
+void CInetUriListQuery::DoQueryListL()
+	{
+	__PRINTIFNOTOOM__
+	iTestWrapper.Next ( _L ( "Query TLD URIs with Uri and TldQueryType -- Gets White/Black list Host") );
+	const TPtrC8 tldlisturi1 ( KTldTestUri1() );
+	TPolicyQueryArgs query1( &tldlisturi1, EPolicyListType);
+	TQueryResults resultList1;
+	DoQueryTldListInfoL(query1, resultList1);
+
+	__PRINTIFNOTOOM__
+	iTestWrapper.Next ( _L ( "Query TLD URIs with Uri and TldQueryType -- Gets White/Black list Host") );
+	const TPtrC8 tldlisturi2 ( KTldTestUri2() );
+	TPolicyQueryArgs query2( &tldlisturi2, EPolicyListType);
+	TQueryResults resultList2;
+	DoQueryTldListInfoL(query2, resultList2);
+	
+		__PRINTIFNOTOOM__
+	iTestWrapper.Next ( _L ( "Query TLD URIs with Uri and TldQueryType -- Gets White/Black list Host") );
+	const TPtrC8 tldlisturi3 ( KTldTestUri3() );
+	TPolicyQueryArgs query3( &tldlisturi3, EPolicyListType);
+	TQueryResults resultList3;
+	DoQueryTldListInfoL(query3, resultList3);
+	
+		__PRINTIFNOTOOM__
+	iTestWrapper.Next ( _L ( "Query TLD URIs with Uri and TldQueryType -- Gets White/Black list Host") );
+	const TPtrC8 tldlisturi4 ( KTldTestUri4() );
+	TPolicyQueryArgs query4( &tldlisturi4, EPolicyListType);
+	TQueryResults resultList4;
+	DoQueryTldListInfoL(query4, resultList4);
+	
+		__PRINTIFNOTOOM__
+	iTestWrapper.Next ( _L ( "Query TLD URIs with Uri and TldQueryType -- Gets White/Black list Host") );
+	const TPtrC8 tldlisturi5 ( KTldTestUri5() );
+	TPolicyQueryArgs query5( &tldlisturi5, EPolicyListType);
+	TQueryResults resultList5;
+	DoQueryTldListInfoL(query5, resultList5);
+	
+		__PRINTIFNOTOOM__
+	iTestWrapper.Next ( _L ( "Query TLD URIs with Uri and TldQueryType -- Gets White/Black list Host") );
+	const TPtrC8 tldlisturi6 ( KTldTestUri6() );
+	TPolicyQueryArgs query6( &tldlisturi6, EPolicyListType);
+	TQueryResults resultList6;
+	DoQueryTldListInfoL(query6, resultList6);
+	
+		__PRINTIFNOTOOM__
+	iTestWrapper.Next ( _L ( "Query TLD URIs with Uri and TldQueryType -- Gets White/Black list Host") );
+	const TPtrC8 tldlisturi7 ( KTldTestUri7() );
+	TPolicyQueryArgs query7( &tldlisturi7, EPolicyListType);
+	TQueryResults resultList7;
+	DoQueryTldListInfoL(query7, resultList7);
+	
+		__PRINTIFNOTOOM__
+	iTestWrapper.Next ( _L ( "Query TLD URIs with Uri and TldQueryType -- Gets White/Black list Host") );
+	const TPtrC8 tldlisturi8 ( KTldTestUri8() );
+	TPolicyQueryArgs query8( &tldlisturi8, EPolicyListType);
+	TQueryResults resultList8;
+	DoQueryTldListInfoL(query8, resultList8);
+	}
+
+/**
+Tests Fetching Policy data for given Uri
+*/
+void CInetUriListQuery::DoQueryPolcydataL ( TPolicyQueryArgs aArgs, TQueryResults aResults )
+	{
+	TInt error(KErrNone);
+	TRAP( error, iInetUriList.QueryTldInfoL ( aArgs, aResults ) );
+	if(error == KErrNone )
+		{
+		HBufC8* policyData = aResults.CharsetL();
+		delete policyData;	
+		}
+	iTestWrapper.TEST (ETrue);
+	}
+
+/**
+Tests Fetching List type of given Uri
+*/
+void CInetUriListQuery::DoQueryTldListInfoL ( TPolicyQueryArgs aArgs, TQueryResults aResults )
+	{
+	TInt error(KErrNone);
+	TRAP( error, iInetUriList.QueryTldInfoL ( aArgs, aResults ) );
+		if(error == KErrNone )
+		{
+		InetUriList::TListType listType = aResults.ListType();
+		}
+	iTestWrapper.TEST (ETrue);
+	}
+
+TBool CInetUriListQuery::OnQueryResultsL ( RInetUri aUri )
+	{
+	TInt count = iResults.Count ();
+	CleanupClosePushL ( aUri );
+	iResults.AppendL ( aUri );
+	CleanupStack::Pop (); // aUri
+	return ETrue;
+	}
+
+void CInetUriListQuery::MatchQueryResults ()
+	{
+	iTestWrapper.TEST ( iExpectedResults.Count() == iResults.Count() );
+	}
+
+void CInetUriListQuery::Cleanup ()
+	{
+	ClearArray ( iResults );
+	ClearArray ( iExpectedResults );		
+	}
+
+void CInetUriListQuery::ClearArray ( QueryResultsArray& aUriArray )
+	{
+	TInt count = aUriArray.Count ();
+	while ( count > 0 )
+		{
+		aUriArray[--count].Close ();			
+		aUriArray.Remove (count);
+		}
+	aUriArray.Reset ();	
+	TInt count2 = aUriArray.Count ();
+	}
+
+void CInetUriListQuery::AppendExpectedUriL ( const TDesC8& aUri, TServiceType aServiceType )
+	{
+	RInetUri myInetUri = iInetUriList.OpenInetUriL ( aUri, aServiceType );
+	CleanupClosePushL ( myInetUri );
+	iExpectedResults.AppendL ( myInetUri );
+	CleanupStack::Pop ();
+	}
+
+void CInetUriListQuery::DoCleanupL ()
+	{
+	Cleanup ();		
+	}
+
+// -----------------------------------------------------
+
+CInetUriListCleanup* CInetUriListCleanup::NewL ( CTestWrapper& aTest )
+	{
+	CInetUriListCleanup* self = new ( ELeave )CInetUriListCleanup ( aTest );
+	CleanupStack::PushL ( self );
+	self->ConstructL ();
+	CleanupStack::Pop ();
+	return self;
+	}
+
+CInetUriListCleanup::~CInetUriListCleanup ()
+	{
+		
+	}
+
+CInetUriListCleanup::CInetUriListCleanup ( CTestWrapper& aTest )
+: CInetUriListTestsBase ( aTest, ETrue )
+	{
+		
+	}
+
+TBool CInetUriListCleanup::OnQueryResultsL ( RInetUri aUri )
+	{
+	CleanupClosePushL ( aUri );
+	iInetUriList.RemoveL ( aUri );
+	CleanupStack::PopAndDestroy (); // aUri
+	return ETrue;
+	}
+
+void CInetUriListCleanup::DoOperationL ()
+	{
+	TQueryArgs args ( EBrowser );
+	iInetUriList.QueryUriL ( args, this );
+	TQueryArgs args2 ( EWapPush );	
+	iInetUriList.QueryUriL ( args2, this );	
+	}
+
+void CInetUriListCleanup::DoCleanupL ()
+	{
+	// Do nothing
+	}
+
+// -----------------------------------------------------