/*

* Copyright (c) 2008 - 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:    Stif Test Cases Test blocks file.

*		 RunMethodL mentions all the test cases that will be run.

*

*/

// [INCLUDE FILES] - do not remove

#include <e32svr.h>

#include <StifParser.h>

#include <StifTestInterface.h>

#include "telepathygabbletest.h"

#include "telepathygabbletestdata.h"

//glib related include files

#include <glib.h>

#include <glib/gprintf.h>           // for g_stpcpy

#include <string.h>

#include <stdlib.h>

#include <glowmem.h>

//Login related file

#include "telepathygabblelogintest.h"

//Send Message related file

#include "telepathygabblesendmessage.h"

//AddDeleteContact related file

#include "telepathygabbleadddeletecontact.h"

//FetchContacts related files

#include "telepathygabblefetchcontacts.h"

//Search related files

#include "telepathygabblesearch.h"

const TInt KRepeatedMessageCount=4;

typedef enum

{

	RC_OK,

	RC_ERROR

} RC_Code_t;

typedef struct

{

	gchar *recipient;

	gchar *message;

} MessageData;

typedef struct

{

	gchar      *proxy_server;

	gchar      *proxy_port;	

}ProxyData;

typedef struct

{

	gchar      *key;

	gchar      *value;	

}SearchData;

typedef struct

{

	gchar       *server;

	gchar       *username;

	gchar       *password;		

	gchar       *resource;

	MessageData *msg_data;	

#ifdef __WINSCW__

    ProxyData   *proxy_data;

#endif

    gchar       *port;

    gchar       *ssl_flag; //needed for gizmo and gtalk.

    SearchData  *search_data;

} ConnectData;

typedef struct

{

	ConnectData *connect_data;

	GMainLoop   *main_loop;

	RC_Code_t   rCode;	

} AuthData;

typedef struct

{

    GMainLoop *main_loop;

    RC_Code_t Test_Success;	

} HandleData;

// Function to read data from the cfg file

static RC_Code_t read_data ( ConnectData*& connect_data, 

                             CStifItemParser& aItem, CStifLogger* aLog );

// Function to free the allocated resources

static void free_data ( ConnectData*& connect_data, CStifLogger* aLog);

// ============================= LOCAL FUNCTIONS ===============================

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

// function_name	: read_data

// description     	: Reads data from the CFG file

// Returns          : None

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

//

static RC_Code_t

read_data ( ConnectData*& connect_data, CStifItemParser& aItem, CStifLogger* aLog )

    {

	TPtrC               string;

	TBuf8<KMaxFileName> temp;

	//TBuf8<KMaxChar>		temp;

	MessageData         *msg_data   = NULL;

	SearchData         *search_data   = NULL;

#ifdef __WINSCW__

	ProxyData           *proxy_data = NULL;

#endif

	connect_data = g_new0 ( ConnectData, 1 );

	if ( !connect_data )

	    {

		return RC_ERROR;

	    }

	msg_data = g_new0 ( MessageData, 1 );

	if ( !msg_data )

	    {

		free_data (connect_data, aLog );

		return RC_ERROR;

	    }

	connect_data->msg_data = msg_data;

	search_data = g_new0 ( SearchData, 1 );

	if ( !search_data )

	    {

		free_data (connect_data, aLog );

		return RC_ERROR;

	    }

	connect_data->search_data = search_data;	    

#ifdef __WINSCW__

    proxy_data = g_new0 ( ProxyData, 1 );

    if ( !proxy_data ) 

    	{

    	free_data (connect_data, aLog );

    	return RC_ERROR;

    	}

	connect_data->proxy_data = proxy_data;

#endif

	// Read server name

	if ( aItem.GetNextString ( string ) == KErrNone )

	    {

		temp.Copy ( string );

		temp.Append ( '\0' );

		connect_data->server = g_new0 ( gchar, temp.Length() );

		if ( !connect_data->server )

		    {			

			free_data (connect_data, aLog );

			return RC_ERROR;

		    }

		g_stpcpy ( connect_data->server, ( gchar * ) temp.Ptr() ); 

	    }

	// Read Username

	if ( aItem.GetNextString ( string ) == KErrNone )

	    {

	    temp.Copy ( string );

	    temp.Append ( '\0' );

	    connect_data->username = g_new0 ( gchar, temp.Length() );

	    if ( !connect_data->username )

	        {	    	

	    	free_data (connect_data, aLog );

	    	return RC_ERROR;

	        }

	    g_stpcpy ( connect_data->username, ( gchar * ) temp.Ptr() );		    

	    }

	// Read Password corresponding to Username

	if ( aItem.GetNextString ( string ) == KErrNone )

	    {

	    temp.Copy ( string );

	    temp.Append ( '\0' );

	    connect_data->password = g_new0 ( gchar, temp.Length () );		    

	    if ( !connect_data->password )

	        {	    	

	    	free_data (connect_data, aLog );

	    	return RC_ERROR;

	        }

	    g_stpcpy ( connect_data->password, ( gchar *) temp.Ptr() );

	    }

	// Read recipient

	if ( aItem.GetNextString ( string ) == KErrNone )

	    {

	    temp.Copy ( string );

	    temp.Append ( '\0' );

	    msg_data->recipient = g_new0 ( gchar, temp.Length() );

	    if ( !msg_data->recipient )

	        {

	    	free_data (connect_data, aLog );

	    	return RC_ERROR;

	        }

	    g_stpcpy ( msg_data->recipient, ( gchar * ) temp.Ptr() );

	    }

	// Read Message

	if ( aItem.GetNextString ( string ) == KErrNone )

	    {

	    temp.Copy ( string );

	    temp.Append ( '\0' );	    

	    msg_data->message = g_new0 ( gchar, temp.Length() );

	    if ( !msg_data->message )

	        {

	    	free_data (connect_data, aLog );

	    	return RC_ERROR;

	        }

	    g_stpcpy ( msg_data->message, ( gchar * ) temp.Ptr() );

	    }

	// Read resource identifier

	if ( aItem.GetNextString ( string ) == KErrNone )

	    {

	    temp.Copy ( string );

	    temp.Append ( '\0' );

	    connect_data->resource = g_new0 ( gchar, temp.Length() );

	    if ( !connect_data->resource )

	        {

	    	free_data (connect_data, aLog );

	    	return RC_ERROR;

	        }

	    g_stpcpy ( connect_data->resource, ( gchar * ) temp.Ptr() );		    

	    }

	// Read proxy server and proxy port

    if ( aItem.GetNextString ( string ) == KErrNone )

    	{

    	temp.Copy ( string );

    	temp.Append ( '\0' );

    	#ifdef __WINSCW__

    	proxy_data->proxy_server = g_new0 ( gchar, temp.Length() );

    	if ( !proxy_data->proxy_server )

    		{

    		free_data (connect_data, aLog );

    		return RC_ERROR;

    		}

    	g_stpcpy ( proxy_data->proxy_server, ( gchar * ) temp.Ptr() );

    	#endif 

    	}

    if ( aItem.GetNextString ( string ) == KErrNone )

    	{

    	temp.Copy ( string );

    	temp.Append ( '\0' );

    	#ifdef __WINSCW__

    	proxy_data->proxy_port = g_new0 ( gchar, temp.Length() );

    	if ( !proxy_data->proxy_port )

    		{

    		free_data (connect_data, aLog );

    		return RC_ERROR;

    		}

    	g_stpcpy ( proxy_data->proxy_port, ( gchar * ) temp.Ptr() );

    	#endif

    	}	

    	/* if ( aItem.GetNextInt ( proxy_port ) == KErrNone )

    		{

    		proxy_data->proxy_port = proxy_port;

    		}    	 */

	//Read the port

	if ( aItem.GetNextString ( string ) == KErrNone )

	{

	temp.Copy ( string );

	temp.Append ( '\0' );

	connect_data->port = g_new0 ( gchar, temp.Length() );

	if ( !connect_data->port )

		{

		free_data (connect_data, aLog );

		return RC_ERROR;

		}

	g_stpcpy ( connect_data->port, ( gchar * ) temp.Ptr() ); 

	}

	//Read the ssl_flag value

  	if ( aItem.GetNextString ( string ) == KErrNone )

    {

	temp.Copy ( string );

	temp.Append ( '\0' );

	connect_data->ssl_flag = g_new0 ( gchar, temp.Length() );

	if ( !connect_data->ssl_flag )

	    {			

		free_data (connect_data, aLog );

		return RC_ERROR;

	    }

	g_stpcpy ( connect_data->ssl_flag, ( gchar * ) temp.Ptr() ); 

    }

    // Read key

	if ( aItem.GetNextString ( string ) == KErrNone )

	    {

	    temp.Copy ( string );

	    temp.Append ( '\0' );

	    search_data->key = g_new0 ( gchar, temp.Length() );

	    if ( !search_data->key )

	        {

	    	free_data (connect_data, aLog );

	    	return RC_ERROR;

	        }

	    g_stpcpy ( search_data->key, ( gchar * ) temp.Ptr() );

	    }

	// Read value

	if ( aItem.GetNextString ( string ) == KErrNone )

	    {

	    temp.Copy ( string );

	    temp.Append ( '\0' );	    

	    search_data->value = g_new0 ( gchar, temp.Length() );

	    if ( !search_data->value )

	        {

	    	free_data (connect_data, aLog );

	    	return RC_ERROR;

	        }

	    g_stpcpy ( search_data->value, ( gchar * ) temp.Ptr() );

	    }

	return RC_OK;

    }

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

// function_name	: free_data

// description     	: Deallocates all the data

// Returns          : None

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

//

static void

free_data ( ConnectData*& connect_data, CStifLogger* aLog )

    {

    //iLog->Log( _L("free_data\n") );

	if ( connect_data )

	    {

		if ( connect_data->server )

		    {

		    //iLog->Log( _L("free server\n") );

			g_free ( connect_data->server );

			connect_data->server = NULL;

		    }

		if ( connect_data->username )

		    {

		    aLog->Log( _L(" free username\n") );

			g_free ( connect_data->username );

			connect_data->username = NULL;

		    }

		if ( connect_data->password )

		    {

		    aLog->Log( _L(" free password\n") );

			g_free ( connect_data->password );

			connect_data->password = NULL;

		    }

		if ( connect_data->msg_data )

		    {

			if ( connect_data->msg_data->recipient )

			    {

			    aLog->Log( _L(" free recipient\n") );

				g_free ( connect_data->msg_data->recipient );

				connect_data->msg_data->recipient = NULL;

			    }

			if ( connect_data->msg_data->message )

			    {

			    aLog->Log( _L(" free message\n") );

				g_free ( connect_data->msg_data->message );

				connect_data->msg_data->message = NULL;

			    }

			g_free ( connect_data->msg_data );

			connect_data->msg_data = NULL;

		    }		

		if ( connect_data->resource )

		    {

		    aLog->Log( _L(" free resource\n") );

			g_free ( connect_data->resource );

			connect_data->resource = NULL;

		    }

	#ifdef __WINSCW__

	    if ( connect_data->proxy_data )

	    	{

	    	if ( connect_data->proxy_data->proxy_server )

	    		{

	    		aLog->Log( _L(" free proxy_server\n") );

	    		g_free ( connect_data->proxy_data->proxy_server );

	    		connect_data->proxy_data->proxy_server = NULL;

	    		}

    		if ( connect_data->proxy_data->proxy_port )

	    		{

	    		aLog->Log( _L(" free proxy_port\n") );

	    		g_free ( connect_data->proxy_data->proxy_port );

	    		connect_data->proxy_data->proxy_port = NULL;

	    		}

	    	g_free ( connect_data->proxy_data );

	    	connect_data->proxy_data = NULL;	

	    	}

	#endif	 

	    //port free

	    if ( connect_data->port )

		    {

		    aLog->Log( _L(" free port\n") );

			g_free ( connect_data->port );

			connect_data->port = NULL;

		    }

		//ssl_flag free

		if ( connect_data->ssl_flag )

		    {

		        aLog->Log( _L(" free ssl_flag\n") );

				g_free ( connect_data->ssl_flag );

				connect_data->ssl_flag = NULL;

		    }

		if ( connect_data->search_data )

		    {

			if ( connect_data->search_data->key )

			    {

			    aLog->Log( _L(" free key\n") );

				g_free ( connect_data->search_data->key );

				connect_data->search_data->key = NULL;

			    }

			if ( connect_data->search_data->value )

			    {

			    aLog->Log( _L(" free value\n") );

				g_free ( connect_data->search_data->value );

				connect_data->search_data->value = NULL;

			    }

			g_free ( connect_data->search_data );

			connect_data->search_data = NULL;

		    }

		aLog->Log( _L(" free connect_data\n") );		    		    

		g_free ( connect_data );

		connect_data = NULL;    

	    }

	    aLog->Log( _L(" free connect_data out\n") );

    }

// ============================ MEMBER FUNCTIONS ===============================

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

// CTelepathyGabbleTest::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

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

//

void CTelepathyGabbleTest::Delete() 

    {

    	 iLog->Log( _L("CTelepathyGabbleTest::Delete in\n") );

	     if (iLoginObj)

	     {

	       	iLog->Log( _L("In Delete iLoginObj \n") );

	     	delete iLoginObj;

	     	iLoginObj = NULL;

	     }

		 if (iSendMsgObj)

		 {

		 	delete iSendMsgObj;

		 	iSendMsgObj = NULL;

		 }

		 if (iAddDelContactObj)

		 {

		 	delete iAddDelContactObj;

		 	iAddDelContactObj = NULL;

		 }

		 if (iFetchContactObj)

		 {

		 	delete iFetchContactObj;

		 	iFetchContactObj = NULL;

		 }

		 if (iSearchObj)

		 {

		 	delete iSearchObj;

		 	iSearchObj = NULL;

		 }

		 if (iTestData)

		 {

		    iLog->Log( _L("In Delete iTestData \n") );

		 	delete iTestData;

		 	iTestData = NULL;

		 }

		 iLog->Log( _L("CTelepathyGabbleTest::Delete out\n") );

    }

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

// CTelepathyGabbleTest::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

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

//

TInt CTelepathyGabbleTest::RunMethodL( 

    CStifItemParser& aItem )