1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:    Stif Test Cases Test blocks file.

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

    16 *

    17 */

    18 

    19 

    20 

    21 

    22 

    23 // [INCLUDE FILES] - do not remove

    24 #include <e32svr.h>

    25 #include <StifParser.h>

    26 #include <StifTestInterface.h>

    27 #include "telepathygabbletest.h"

    28 #include "telepathygabbletestdata.h"

    29 //glib related include files

    30 #include <glib.h>

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

    32 #include <string.h>

    33 #include <stdlib.h>

    34 

    35 #include <glowmem.h>

    36 

    37 //Login related file

    38 #include "telepathygabblelogintest.h"

    39 //Send Message related file

    40 #include "telepathygabblesendmessage.h"

    41 //AddDeleteContact related file

    42 #include "telepathygabbleadddeletecontact.h"

    43 //FetchContacts related files

    44 #include "telepathygabblefetchcontacts.h"

    45 //Search related files

    46 #include "telepathygabblesearch.h"

    47 

    48 

    49 const TInt KRepeatedMessageCount=4;

    50 

    51 

    52 

    53 typedef enum

    54 {

    55 	RC_OK,

    56 	RC_ERROR

    57 } RC_Code_t;

    58 

    59 typedef struct

    60 {

    61 	gchar *recipient;

    62 	gchar *message;

    63 } MessageData;

    64 

    65 typedef struct

    66 {

    67 	gchar      *proxy_server;

    68 	gchar      *proxy_port;	

    69 }ProxyData;

    70 

    71 typedef struct

    72 {

    73 	gchar      *key;

    74 	gchar      *value;	

    75 }SearchData;

    76 typedef struct

    77 {

    78 	gchar       *server;

    79 	gchar       *username;

    80 	gchar       *password;		

    81 	gchar       *resource;

    82 	MessageData *msg_data;	

    83 #ifdef __WINSCW__

    84     ProxyData   *proxy_data;

    85 #endif

    86     gchar       *port;

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

    88     SearchData  *search_data;

    89 

    90 } ConnectData;

    91 

    92 typedef struct

    93 {

    94 	ConnectData *connect_data;

    95 	GMainLoop   *main_loop;

    96 	RC_Code_t   rCode;	

    97 } AuthData;

    98 

    99 typedef struct

   100 {

   101     GMainLoop *main_loop;

   102     RC_Code_t Test_Success;	

   103 } HandleData;

   104 

   105 // Function to read data from the cfg file

   106 static RC_Code_t read_data ( ConnectData*& connect_data, 

   107                              CStifItemParser& aItem, CStifLogger* aLog );

   108                              

   109 // Function to free the allocated resources

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

   111                              

   112 

   113                              

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

   115 

   116 //-----------------------------------------------------------------------------

   117 // function_name	: read_data

   118 // description     	: Reads data from the CFG file

   119 // Returns          : None

   120 //-----------------------------------------------------------------------------

   121 //

   122 static RC_Code_t

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

   124     {

   125 	TPtrC               string;

   126 	TBuf8<KMaxFileName> temp;

   127 	

   128 	//TBuf8<KMaxChar>		temp;

   129 	MessageData         *msg_data   = NULL;

   130 	

   131 	SearchData         *search_data   = NULL;

   132 #ifdef __WINSCW__

   133 	ProxyData           *proxy_data = NULL;

   134 #endif

   135 	

   136 	connect_data = g_new0 ( ConnectData, 1 );

   137 	if ( !connect_data )

   138 	    {

   139 		return RC_ERROR;

   140 	    }

   141 	    

   142 	msg_data = g_new0 ( MessageData, 1 );

   143 	if ( !msg_data )

   144 	    {

   145 		free_data (connect_data, aLog );

   146 		return RC_ERROR;

   147 	    }

   148 	

   149 	connect_data->msg_data = msg_data;

   150 	

   151 	search_data = g_new0 ( SearchData, 1 );

   152 	if ( !search_data )

   153 	    {

   154 		free_data (connect_data, aLog );

   155 		return RC_ERROR;

   156 	    }

   157 	connect_data->search_data = search_data;	    

   158 	

   159 #ifdef __WINSCW__

   160     proxy_data = g_new0 ( ProxyData, 1 );

   161     if ( !proxy_data ) 

   162     	{

   163     	free_data (connect_data, aLog );

   164     	return RC_ERROR;

   165     	}

   166 	connect_data->proxy_data = proxy_data;

   167 #endif

   168 

   169 	// Read server name

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

   171 	    {

   172 		temp.Copy ( string );

   173 		temp.Append ( '\0' );

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

   175 		if ( !connect_data->server )

   176 		    {			

   177 			free_data (connect_data, aLog );

   178 			return RC_ERROR;

   179 		    }

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

   181 	    }

   182 	    

   183 	// Read Username

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

   185 	    {

   186 	    temp.Copy ( string );

   187 	    temp.Append ( '\0' );

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

   189 	    if ( !connect_data->username )

   190 	        {	    	

   191 	    	free_data (connect_data, aLog );

   192 	    	return RC_ERROR;

   193 	        }

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

   195 	    }

   196 	

   197 	// Read Password corresponding to Username

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

   199 	    {

   200 	    temp.Copy ( string );

   201 	    temp.Append ( '\0' );

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

   203 	    if ( !connect_data->password )

   204 	        {	    	

   205 	    	free_data (connect_data, aLog );

   206 	    	return RC_ERROR;

   207 	        }

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

   209 	    }

   210 	

   211 	// Read recipient

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

   213 	    {

   214 	    temp.Copy ( string );

   215 	    temp.Append ( '\0' );

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

   217 	    if ( !msg_data->recipient )

   218 	        {

   219 	    	free_data (connect_data, aLog );

   220 	    	return RC_ERROR;

   221 	        }

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

   223 	    }

   224 	

   225 	// Read Message

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

   227 	    {

   228 	    temp.Copy ( string );

   229 	    temp.Append ( '\0' );	    

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

   231 	    if ( !msg_data->message )

   232 	        {

   233 	    	free_data (connect_data, aLog );

   234 	    	return RC_ERROR;

   235 	        }

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

   237 	    }

   238 	

   239 	// Read resource identifier

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

   241 	    {

   242 	    temp.Copy ( string );

   243 	    temp.Append ( '\0' );

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

   245 	    if ( !connect_data->resource )

   246 	        {

   247 	    	free_data (connect_data, aLog );

   248 	    	return RC_ERROR;

   249 	        }

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

   251 	    }

   252 	 

   253 

   254 	// Read proxy server and proxy port

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

   256     	{

   257     	temp.Copy ( string );

   258     	temp.Append ( '\0' );

   259     	#ifdef __WINSCW__

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

   261     	if ( !proxy_data->proxy_server )

   262     		{

   263     		free_data (connect_data, aLog );

   264     		return RC_ERROR;

   265     		}

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

   267     	#endif 

   268     	}

   269     	

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

   271     	{

   272     	temp.Copy ( string );

   273     	temp.Append ( '\0' );

   274     	#ifdef __WINSCW__

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

   276     	if ( !proxy_data->proxy_port )

   277     		{

   278     		free_data (connect_data, aLog );

   279     		return RC_ERROR;

   280     		}

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

   282     	#endif

   283     	}	

   284     	

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

   286     		{

   287     		proxy_data->proxy_port = proxy_port;

   288     		}    	 */

   289     		

   290     		

   291 

   292 	//Read the port

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

   294 	{

   295 	temp.Copy ( string );

   296 	temp.Append ( '\0' );

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

   298 	if ( !connect_data->port )

   299 		{

   300 		free_data (connect_data, aLog );

   301 		return RC_ERROR;

   302 		}

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

   304 	}

   305 

   306 	//Read the ssl_flag value

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

   308     {

   309 	temp.Copy ( string );

   310 	temp.Append ( '\0' );

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

   312 	if ( !connect_data->ssl_flag )

   313 	    {			

   314 		free_data (connect_data, aLog );

   315 		return RC_ERROR;

   316 	    }

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

   318     }

   319     

   320     // Read key

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

   322 	    {

   323 	    temp.Copy ( string );

   324 	    temp.Append ( '\0' );

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

   326 	    if ( !search_data->key )

   327 	        {

   328 	    	free_data (connect_data, aLog );

   329 	    	return RC_ERROR;

   330 	        }

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

   332 	    }

   333 	

   334 	// Read value

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

   336 	    {

   337 	    temp.Copy ( string );

   338 	    temp.Append ( '\0' );	    

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

   340 	    if ( !search_data->value )

   341 	        {

   342 	    	free_data (connect_data, aLog );

   343 	    	return RC_ERROR;

   344 	        }

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

   346 	    }

   347 	

   348 	return RC_OK;

   349     }

   350     

   351 

   352 

   353 //-----------------------------------------------------------------------------

   354 // function_name	: free_data

   355 // description     	: Deallocates all the data

   356 // Returns          : None

   357 //-----------------------------------------------------------------------------

   358 //

   359 static void

   360 free_data ( ConnectData*& connect_data, CStifLogger* aLog )

   361     {

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

   363 	if ( connect_data )

   364 	    {

   365 		if ( connect_data->server )

   366 		    {

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

   368 			g_free ( connect_data->server );

   369 			connect_data->server = NULL;

   370 		    }

   371 		

   372 		if ( connect_data->username )

   373 		    {

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

   375 			g_free ( connect_data->username );

   376 			connect_data->username = NULL;

   377 		    }

   378 		

   379 		if ( connect_data->password )

   380 		    {

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

   382 			g_free ( connect_data->password );

   383 			connect_data->password = NULL;

   384 		    }

   385 		

   386 		if ( connect_data->msg_data )

   387 		    {

   388 			if ( connect_data->msg_data->recipient )

   389 			    {

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

   391 				g_free ( connect_data->msg_data->recipient );

   392 				connect_data->msg_data->recipient = NULL;

   393 			    }

   394 			if ( connect_data->msg_data->message )

   395 			    {

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

   397 				g_free ( connect_data->msg_data->message );

   398 				connect_data->msg_data->message = NULL;

   399 			    }

   400 			g_free ( connect_data->msg_data );

   401 			connect_data->msg_data = NULL;

   402 		    }		

   403 		

   404 		if ( connect_data->resource )

   405 		    {

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

   407 			g_free ( connect_data->resource );

   408 			connect_data->resource = NULL;

   409 		    }

   410 		    

   411 	#ifdef __WINSCW__

   412 	    if ( connect_data->proxy_data )

   413 	    	{

   414 	    	if ( connect_data->proxy_data->proxy_server )

   415 	    		{

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

   417 	    		g_free ( connect_data->proxy_data->proxy_server );

   418 	    		connect_data->proxy_data->proxy_server = NULL;

   419 	    		}

   420     		if ( connect_data->proxy_data->proxy_port )

   421 	    		{

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

   423 	    		g_free ( connect_data->proxy_data->proxy_port );

   424 	    		connect_data->proxy_data->proxy_port = NULL;

   425 	    		}

   426 	    	g_free ( connect_data->proxy_data );

   427 	    	connect_data->proxy_data = NULL;	

   428 	    	}

   429 	#endif	 

   430 	

   431 	    //port free

   432 	    if ( connect_data->port )

   433 		    {

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

   435 			g_free ( connect_data->port );

   436 			connect_data->port = NULL;

   437 		    }

   438 		    

   439 		//ssl_flag free

   440 		if ( connect_data->ssl_flag )

   441 		    {

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

   443 				g_free ( connect_data->ssl_flag );

   444 				connect_data->ssl_flag = NULL;

   445 		    }

   446 		    

   447 		if ( connect_data->search_data )

   448 		    {

   449 			if ( connect_data->search_data->key )

   450 			    {

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

   452 				g_free ( connect_data->search_data->key );

   453 				connect_data->search_data->key = NULL;

   454 			    }

   455 			if ( connect_data->search_data->value )

   456 			    {

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

   458 				g_free ( connect_data->search_data->value );

   459 				connect_data->search_data->value = NULL;

   460 			    }

   461 			g_free ( connect_data->search_data );

   462 			connect_data->search_data = NULL;

   463 		    }

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

   465 		g_free ( connect_data );

   466 		connect_data = NULL;    

   467 	    }

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

   469     }

   470     

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

   472 

   473 // -----------------------------------------------------------------------------

   474 // CTelepathyGabbleTest::Delete

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

   476 // Called from destructor. 

   477 // -----------------------------------------------------------------------------

   478 //

   479 void CTelepathyGabbleTest::Delete() 

   480     {

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

   482 	     if (iLoginObj)

   483 	     {

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

   485 	     	delete iLoginObj;

   486 	     	iLoginObj = NULL;

   487 	     }

   488 

   489 		 if (iSendMsgObj)

   490 		 {

   491 		 	delete iSendMsgObj;

   492 		 	iSendMsgObj = NULL;

   493 		 }

   494 		 

   495 		 if (iAddDelContactObj)

   496 		 {

   497 		 	delete iAddDelContactObj;

   498 		 	iAddDelContactObj = NULL;

   499 		 }

   500 		 

   501 		 if (iFetchContactObj)

   502 		 {

   503 		 	delete iFetchContactObj;

   504 		 	iFetchContactObj = NULL;

   505 		 }

   506 		 

   507 		 if (iSearchObj)

   508 		 {

   509 		 	delete iSearchObj;

   510 		 	iSearchObj = NULL;

   511 		 }

   512 		 

   513 		 if (iTestData)

   514 		 {

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

   516 		 	delete iTestData;

   517 		 	iTestData = NULL;

   518 		 	

   519 		 }

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

   521     }

   522 

   523 // -----------------------------------------------------------------------------

   524 // CTelepathyGabbleTest::RunMethodL

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

   526 // -----------------------------------------------------------------------------

   527 //

   528 TInt CTelepathyGabbleTest::RunMethodL( 

   529     CStifItemParser& aItem ) 

   530     {

   531     

   532     iLog->Log( _L("CTelepathyGabbleTest::RunMethodL in") );

   533    

   534  

   535     static TStifFunctionInfo const KFunctions[] =

   536         {  

   537         // Copy this line for every implemented function.

   538         // First string is the function name used in TestScripter script file.

   539         // Second is the actual implementation member function. 

   540         //ENTRY( "Example", CTelepathyGabbleTest::ExampleL ),

   541         //ADD NEW ENTRY HERE

   542         // [test cases entries] - Do not remove

   543         

   544         //Login - Logout related test cases

   545         ENTRY("LoginTest", CTelepathyGabbleTest::LoginTestL ),

   546         ENTRY("LogoutTest", CTelepathyGabbleTest::LogoutTestL ),

   547         ENTRY("LoginInvalidUseridTest", CTelepathyGabbleTest::LoginInvalidUseridTestL ),

   548         ENTRY("LoginInvalidPasswdTest", CTelepathyGabbleTest::LoginInvalidPasswdTestL ),

   549         ENTRY("LoginInvalidUseridPasswdTest", CTelepathyGabbleTest::LoginInvalidUseridPasswdTestL ),

   550         ENTRY("LoginblankUseridTest", CTelepathyGabbleTest::LoginblankUseridTestL ),

   551         ENTRY("LoginblankPasswdTest", CTelepathyGabbleTest::LoginblankPasswdTestL ),

   552         ENTRY("LoginblankUseridblankPasswdTest", CTelepathyGabbleTest::LoginblankUseridblankPasswdTestL ),

   553         ENTRY("LoginWithMaxLengthUserIDTest", CTelepathyGabbleTest::LoginTestL ),

   554         ENTRY("LoginWithMinLengthUserIDTest", CTelepathyGabbleTest::LoginTestL ),

   555         ENTRY("LoginUseridWithSplChrsTest", CTelepathyGabbleTest::LoginInvalidUseridTestL ),

   556         ENTRY("LoginCancelTest", CTelepathyGabbleTest::LoginCancelTestL ),

   557         

   558         

   559         //Send Message related Test Cases

   560         ENTRY("SendMessageTest", CTelepathyGabbleTest::SendMessageTestL ),

   561         ENTRY("SendMesasgeToMaxLengthUserIDTest", CTelepathyGabbleTest::SendMessageTestL ),        

   562 		ENTRY("SendMesasgetoofflinecontactTest", CTelepathyGabbleTest::SendMessagetoinvalidUseridTestL ),

   563         ENTRY("SendMessageWith400Test", CTelepathyGabbleTest::SendMessageWith400TestL ),

   564         ENTRY("SendMesasgeBlankTest", CTelepathyGabbleTest::SendMesasgeBlankTestL ),

   565         ENTRY("SendMesasgeToBlankUserIdTest", CTelepathyGabbleTest::SendMesasgeToBlankUserIdTestL ),

   566         ENTRY("SendMesasgeSplCharsTest", CTelepathyGabbleTest::SendMessageTestL ),

   567         ENTRY("SendMesasgeEmoticonsTest", CTelepathyGabbleTest::SendMessageTestL ),        

   568         ENTRY("SendMessageRepeatedTest",CTelepathyGabbleTest:: SendMessageRepeatedTestL),        

   569         ENTRY("SendMessagetoUserNotInContactListTest",CTelepathyGabbleTest:: SendMessageTestL),

   570         ENTRY("SendMessagetoinvalidUseridTest",CTelepathyGabbleTest:: SendMessagetoinvalidUseridTestL),

   571         

   572         //Receive Message related Test Cases

   573         ENTRY("ReceiveMessageTest", CTelepathyGabbleTest::ReceiveMessageTestL ),

   574         ENTRY("ReceiveMessageMaxLengthTest", CTelepathyGabbleTest::ReceiveMessageMaxLengthTestL ),

   575         ENTRY("ReceiveMessageWithSplChrsTest", CTelepathyGabbleTest::ReceiveMessageTestL ),  

   576         ENTRY("ReceiveMessageWithEmoticonsTest", CTelepathyGabbleTest::ReceiveMessageTestL ),                

   577         ENTRY("ReceiveMessageBlankTest", CTelepathyGabbleTest::ReceiveMessageBlankTestL ),

   578         ENTRY("ReceiveRepeatedMessageTest", CTelepathyGabbleTest::ReceiveRepeatedMessageTestL ),

   579         

   580         //Add Contact related test cases

   581         ENTRY("AddContactTest", CTelepathyGabbleTest::AddContactTestL ),

   582         ENTRY("AddContactWithMaxLengthUserIdTest", CTelepathyGabbleTest::AddContactTestL ),

   583         ENTRY("AddContactWithBlankUserIdTest", CTelepathyGabbleTest::AddContactWithBlankUserIdTestL ),       

   584         ENTRY("AddContactinvalidTest", CTelepathyGabbleTest::AddContactTestL ),

   585         ENTRY("AddContactinvalidWithSplCharsTest", CTelepathyGabbleTest::AddContactTestL ),

   586         ENTRY("AddContactAlreadyInRosterTest", CTelepathyGabbleTest::AddContactAlreadyInRosterTestL ),

   587         

   588         

   589         //Remove Contact related test cases

   590         ENTRY("RemoveContactTest", CTelepathyGabbleTest::RemoveContactTestL ),

   591         ENTRY("RemoveInvalidContactTest", CTelepathyGabbleTest::RemoveInvalidContactTestL),

   592         ENTRY("RemoveContactAlreadyRemovedTest", CTelepathyGabbleTest::RemoveInvalidContactTestL ),

   593         ENTRY("RemoveContactWithMaxLengthUserIDTest", CTelepathyGabbleTest::RemoveContactTestL ),

   594         ENTRY("RemoveContactWithBlankUserIdTest", CTelepathyGabbleTest::RemoveContactWithBlankUserIdTestL ),       

   595         

   596         //Fetch Contact related test cases

   597         ENTRY("FetchContactsTest", CTelepathyGabbleTest::FetchContactsTestL ),

   598         ENTRY("FetchZeroContactTest", CTelepathyGabbleTest::FetchContactsTestL ),

   599        

   600         //Search related test cases

   601         ENTRY("SearchTest", CTelepathyGabbleTest::SearchTestL ),

   602         ENTRY("GetSearchKeysTest", CTelepathyGabbleTest::GetSearchKeysTestL ),

   603         ENTRY("SearchInvalidKeyTest", CTelepathyGabbleTest::SearchInvalidKeyTestL ),

   604         ENTRY("SearchNoKeyValueTest", CTelepathyGabbleTest::SearchNoKeyValueTestL ),

   605         ENTRY("SearchTwoInvalidKeysTest", CTelepathyGabbleTest::SearchTwoInvalidKeysTestL ),        

   606         ENTRY("SearchWithAllKeysTest", CTelepathyGabbleTest::SearchWithAllKeysTestL ),

   607         ENTRY("SearchBlankStringTest", CTelepathyGabbleTest::SearchBlankStringTestL ),

   608         ENTRY("SearchTwiceTest", CTelepathyGabbleTest::SearchTwiceTestL ),

   609         ENTRY("SearchTwiceWithDiffStringsTest", CTelepathyGabbleTest::SearchTwiceWithDiffStringsTestL ),

   610         ENTRY("SearchFiveTimesTest", CTelepathyGabbleTest::SearchFiveTimesTestL ),        

   611         ENTRY("SearchAfterGetSearchKeys", CTelepathyGabbleTest::SearchAfterGetSearchKeysL ),

   612         };

   613 

   614     const TInt count = sizeof( KFunctions ) / 

   615                         sizeof( TStifFunctionInfo );

   616 

   617     return RunInternalL( KFunctions, count, aItem );

   618 

   619     }

   620 

   621 // -----------------------------------------------------------------------------

   622 // CTelepathyGabbleTest::LoginTestL

   623 // Test for login.

   624 // -----------------------------------------------------------------------------

   625 //

   626 

   627 TInt CTelepathyGabbleTest::LoginTestL( 

   628     CStifItemParser& aItem  )

   629 	{

   630 		//Pass the parameters to action_login() from the 

   631 		//data mentioned in the cfg file.

   632 		

   633 		iLog->Log( _L("LoginTestL starting") );

   634 		

   635 		ConnectData  *connect_data = NULL;

   636 		

   637 		if ( read_data ( connect_data, aItem, iLog) != RC_OK )

   638 		{

   639 			//iLog->Log( _L("read_data failed") );

   640 			free_data (connect_data, iLog );

   641 			return KErrGeneral;

   642 		}

   643 		

   644 

   645 		char *username, *passwd , *servername , *resource_login, *ssl_flag, *port;

   646 		char *proxy_server = NULL;

   647 		char *proxy_port = NULL;

   648 		

   649 		username = 	connect_data->username;

   650 		passwd   =  connect_data->password;

   651 		servername = 	connect_data->server;

   652 		resource_login = connect_data->resource;

   653 		ssl_flag = connect_data->ssl_flag;

   654 		port = connect_data->port;

   655 		#ifdef __WINSCW__

   656 	  	proxy_server = connect_data->proxy_data->proxy_server;

   657 			proxy_port = connect_data->proxy_data->proxy_port;

   658 		#endif

   659 		

   660 		iTestData = CTestData::NewL(iLog);

   661 		

   662 		iLog->Log( _L("iTestData created") );

   663 	

   664 		iLoginObj = CTelepathyGabbleLoginTest::NewL();

   665 		

   666 		iLog->Log( _L("iLoginObj created") );

   667 			

   668 		iTestData->SetTestType(CTestData::ELogin) ;

   669 		

   670 		//action_login will have parameters 

   671 		//passed from cfg file

   672 		TInt login_status = 

   673 			iLoginObj->action_login(username,passwd,servername, resource_login,ssl_flag,

   674 																port,proxy_server, proxy_port, iTestData);

   675 			

   676 		

   677 		iLog->Log( _L("after action_login") );

   678 		

   679 		if (login_status == CTestData::ECONNECTED)

   680 		{

   681 			//Do the logout so that all the resources are deallocated properly

   682 			login_status = iLoginObj->action_logout(iTestData);

   683 			

   684 			iLog->Log( _L("after action_logout") );

   685 			

   686 			free_data (connect_data, iLog);

   687 			

   688 			iLog->Log( _L("after free_data") );

   689 			if (login_status != CTestData::EDISCONNECTED)

   690 			{

   691 			iLog->Log( _L("logout failed") );

   692 			return KErrGeneral; 	//logout didnot happen successfully.

   693 			}

   694 			

   695 			//we completed login and logout successfully.

   696 			iLog->Log( _L("login-logout test case passed\n") );

   697 			

   698 			if (iTestData)

   699 			 { 	iLog->Log( _L("delete iTestData \n") );

   700 			 	delete iTestData;

   701 			 	iTestData = NULL;

   702 			 	

   703 			 }

   704 			 if (iLoginObj)

   705 		     {

   706 		       	iLog->Log( _L("delete iLoginObj \n") );

   707 		     	delete iLoginObj;

   708 		     	iLoginObj = NULL;

   709 		     }

   710 			return KErrNone;

   711 		}

   712 		else

   713 		{

   714 			//Login didnot happen successfully.

   715 			//return from here itself, no need for a logout

   716 			free_data (connect_data, iLog );

   717 			iLog->Log( _L("login test case failed") );

   718 			return KErrGeneral;

   719 		

   720 		}

   721 	

   722 	}

   723 

   724 

   725 // -----------------------------------------------------------------------------

   726 // CTelepathyGabbleTest::LoginblankUseridblankPasswdTestL

   727 // -----------------------------------------------------------------------------		

   728 TInt CTelepathyGabbleTest::LoginblankUseridblankPasswdTestL( 

   729     CStifItemParser& aItem  )

   730 	{

   731 		//Pass the parameters to action_login() from the 

   732 		//data mentioned in the cfg file.

   733 		

   734 		ConnectData  *connect_data = NULL;

   735 		

   736 		if ( read_data ( connect_data, aItem, iLog ) != RC_OK )

   737 		{

   738 			free_data ( connect_data,iLog );

   739 			return KErrGeneral;

   740 		}

   741 		

   742 

   743 		char *username, *passwd , *servername , *resource_login, *ssl_flag, *port;

   744 		char *proxy_server = NULL;

   745 		char *proxy_port = NULL;

   746 		

   747 		

   748 		username = 	""; //make the username as blank

   749 		passwd   =  ""; //make the username as blank

   750 		servername = 	connect_data->server;

   751 		resource_login = connect_data->resource;

   752 		ssl_flag = connect_data->ssl_flag;

   753 		port = connect_data->port;

   754 		#ifdef __WINSCW__

   755 	  	proxy_server = connect_data->proxy_data->proxy_server;

   756 			proxy_port = connect_data->proxy_data->proxy_port;

   757 		#endif

   758 		

   759 		

   760 		iTestData = CTestData::NewL(iLog);

   761 	

   762 		iLoginObj = CTelepathyGabbleLoginTest::NewL();

   763 		

   764 		iTestData->SetTestType(CTestData::ELogin) ;

   765 			

   766 		//action_login will have parameters 

   767 		//passed from cfg file

   768 		TInt login_status = 

   769 			iLoginObj->action_login(username,passwd,servername, resource_login, ssl_flag,

   770 															port,proxy_server, proxy_port,iTestData);

   771 		

   772 		free_data (connect_data, iLog );

   773 		

   774 		if (login_status == CTestData::EDISCONNECTED)

   775 		{

   776 			//login_status is disconnected(default state) 

   777 			//which is correct since the username was blank.

   778 			

   779 			return KErrNone;

   780 		}

   781 		else

   782 		{

   783 			//There was some error

   784 			return KErrGeneral;

   785 		}

   786 			

   787 	}

   788 

   789 // -----------------------------------------------------------------------------

   790 // CTelepathyGabbleTest::LoginblankUseridTestL

   791 // -----------------------------------------------------------------------------		

   792 TInt CTelepathyGabbleTest::LoginblankUseridTestL( 

   793     CStifItemParser& aItem  )

   794 	{

   795 		//Pass the parameters to action_login() from the 

   796 		//data mentioned in the cfg file.

   797 		

   798 		ConnectData  *connect_data = NULL;

   799 		

   800 		if ( read_data ( connect_data, aItem, iLog ) != RC_OK )

   801 		{

   802 			free_data ( connect_data,iLog );

   803 			return KErrGeneral;

   804 		}

   805 		

   806 

   807 		char *username, *passwd , *servername , *resource_login, *ssl_flag, *port;

   808 		char *proxy_server = NULL;

   809 		char *proxy_port = NULL;

   810 		

   811 		

   812 		username = 	""; //make the username as blank

   813 		passwd   =  connect_data->password;

   814 		servername = 	connect_data->server;

   815 		resource_login = connect_data->resource;

   816 		ssl_flag = connect_data->ssl_flag;

   817 		port = connect_data->port;

   818 		#ifdef __WINSCW__

   819 	  	proxy_server = connect_data->proxy_data->proxy_server;

   820 			proxy_port = connect_data->proxy_data->proxy_port;

   821 		#endif

   822 		

   823 		

   824 		iTestData = CTestData::NewL(iLog);

   825 	

   826 		iLoginObj = CTelepathyGabbleLoginTest::NewL();

   827 		

   828 		iTestData->SetTestType(CTestData::ELogin) ;

   829 			

   830 		//action_login will have parameters 

   831 		//passed from cfg file

   832 		TInt login_status = 

   833 			iLoginObj->action_login(username,passwd,servername, resource_login, ssl_flag,

   834 															port,proxy_server, proxy_port,iTestData);

   835 		

   836 		free_data (connect_data, iLog );

   837 		

   838 		if (login_status == CTestData::EDISCONNECTED)

   839 		{

   840 			//login_status is disconnected(default state) 

   841 			//which is correct since the username was blank.

   842 			

   843 			return KErrNone;

   844 		}

   845 		else

   846 		{

   847 			//There was some error

   848 			return KErrGeneral;

   849 		}

   850 			

   851 	}

   852 

   853 // -----------------------------------------------------------------------------

   854 // CTelepathyGabbleTest::LoginblankPasswdTestL

   855 // -----------------------------------------------------------------------------	

   856 TInt CTelepathyGabbleTest::LoginblankPasswdTestL( 

   857 CStifItemParser& aItem  )

   858 {

   859 	//Pass the parameters to action_login() from the 

   860 	//data mentioned in the cfg file.

   861 	

   862 	ConnectData  *connect_data = NULL;

   863 	

   864 	if ( read_data ( connect_data, aItem, iLog ) != RC_OK )

   865 	{

   866 		free_data ( connect_data, iLog );

   867 		return KErrGeneral;

   868 	}

   869 

   870 	char *username, *passwd , *servername , *resource_login,*ssl_flag, *port;

   871 	char *proxy_server = NULL;

   872 	char *proxy_port = NULL;

   873 		

   874 	

   875 	username = 	connect_data->username;

   876 	passwd   =  ""; //make the passwd as blank.

   877 	servername = 	connect_data->server;

   878 	resource_login = connect_data->resource;

   879 	ssl_flag = connect_data->ssl_flag;

   880 	port = connect_data->port;

   881 		#ifdef __WINSCW__

   882 	  		proxy_server = connect_data->proxy_data->proxy_server;

   883 			proxy_port = connect_data->proxy_data->proxy_port;

   884 		#endif

   885 		

   886 	

   887 	iTestData = CTestData::NewL(iLog);

   888 

   889 	iLoginObj = CTelepathyGabbleLoginTest::NewL();

   890 	

   891 	iTestData->SetTestType(CTestData::ELogin) ;

   892 		

   893 	//action_login will have parameters 

   894 	//passed from cfg file

   895 	TInt login_status = 

   896 		iLoginObj->action_login(username,passwd,servername, resource_login,ssl_flag,

   897 														port,proxy_server, proxy_port,iTestData);

   898 	

   899 	free_data (connect_data, iLog );

   900 	

   901 	if (login_status == CTestData::EDISCONNECTED)

   902 	{

   903 		//the status is disconnected which is correct since the 

   904 		//login didnot happen with blank passwd.

   905 		return KErrNone;

   906 	}

   907 	else

   908 	{

   909 		return KErrGeneral;

   910 	

   911 	}			

   912 }

   913 

   914 

   915 

   916 // -----------------------------------------------------------------------------

   917 // CTelepathyGabbleTest::LogoutTestL

   918 // Test for logout

   919 // -----------------------------------------------------------------------------

   920 TInt CTelepathyGabbleTest::LogoutTestL( 

   921 CStifItemParser& aItem  )

   922 {

   923 	//Pass the parameters to action_login() from the 

   924 	//data mentioned in the cfg file.

   925 	

   926 	ConnectData  *connect_data = NULL;

   927 	

   928 	if ( read_data ( connect_data, aItem, iLog ) != RC_OK )

   929 	{

   930 		free_data ( connect_data, iLog );

   931 		return KErrGeneral;

   932 	}

   933 	

   934 

   935 	char *username, *passwd , *servername , *resource_login, *ssl_flag, *port;

   936 	char *proxy_server = NULL;

   937 	char *proxy_port = NULL;

   938 		

   939 	

   940 	username = 	connect_data->username;

   941 	passwd   =  connect_data->password;

   942 	servername = 	connect_data->server;

   943 	resource_login = connect_data->resource;

   944 	ssl_flag = connect_data->ssl_flag;

   945 	port = connect_data->port;

   946 	#ifdef __WINSCW__

   947   		proxy_server = connect_data->proxy_data->proxy_server;

   948 		proxy_port = connect_data->proxy_data->proxy_port;

   949 	#endif

   950 		

   951 	

   952 	iTestData = CTestData::NewL(iLog);

   953 	

   954 	iLoginObj = CTelepathyGabbleLoginTest::NewL();

   955 	

   956 	iTestData->SetTestType(CTestData::ELogin);

   957 	

   958 	//action_login will have parameters 

   959 	//passed from cfg file

   960 	

   961 	TInt login_status = iLoginObj->action_login(username,passwd,servername, resource_login,ssl_flag,

   962 																							port,proxy_server, proxy_port,iTestData);

   963 	

   964 	

   965 	if (login_status == CTestData::ECONNECTED)

   966 	{

   967 		//If the login variable is ECONNECTED

   968 		//Do the Logout

   969 		login_status = iLoginObj->action_logout(iTestData);

   970 		

   971 	

   972 		if (login_status == CTestData::EDISCONNECTED)

   973 		{

   974 	

   975 			//the logout happened succesfully

   976 			free_data ( connect_data, iLog );

   977 			return KErrNone;

   978 		}

   979 		else 

   980 		{

   981 			//login_status is still connected, there was a problem 

   982 			//in logging out.

   983 			free_data ( connect_data, iLog );

   984 			return KErrGeneral;

   985 		}

   986 		

   987 	}

   988 	else

   989 	{

   990 		//Login itself didnot happen.

   991 		free_data ( connect_data, iLog );

   992 		return KErrGeneral;

   993 	}

   994 		

   995 }

   996 

   997 

   998 

   999 // -----------------------------------------------------------------------------

  1000 // CTelepathyGabbleTest::SearchAfterGetSearchKeysL

  1001 // -----------------------------------------------------------------------------

  1002 

  1003 TInt CTelepathyGabbleTest::SearchAfterGetSearchKeysL( CStifItemParser& aItem  )

  1004 	{

  1005 		TInt return_value = KErrNone;

  1006 		//Pass the parameters to action_login() from the 

  1007 		//data mentioned in the cfg file.

  1008 		

  1009 		//step 1: Do the login.

  1010 		ConnectData  *connect_data = NULL;

  1011 		

  1012 		if ( read_data ( connect_data, aItem, iLog ) != RC_OK )

  1013 		{

  1014 			free_data ( connect_data, iLog );

  1015 			return KErrGeneral;

  1016 		}

  1017 		

  1018 

  1019 		//for login

  1020 		char *username, *passwd , *servername , *resource_login, *ssl_flag, *value, *port;

  1021 		char *proxy_server = NULL;

  1022 		char *proxy_port = NULL;

  1023 		

  1024 	

  1025 		username = 	connect_data->username;

  1026 		passwd   =  connect_data->password;

  1027 		servername = 	connect_data->server;

  1028 		resource_login = connect_data->resource;

  1029 		ssl_flag = connect_data->ssl_flag;

  1030 		value = connect_data->msg_data->message;

  1031 		port = connect_data->port;

  1032 		#ifdef __WINSCW__

  1033 	  		proxy_server = connect_data->proxy_data->proxy_server;

  1034 			proxy_port = connect_data->proxy_data->proxy_port;

  1035 		#endif

  1036 		

  1037 

  1038 		if (iTestData == NULL)

  1039 		{

  1040 			//Create the iTestData if it is not existing.

  1041 			

  1042 			iTestData = CTestData::NewL(iLog);

  1043 		}

  1044 		

  1045 		iTestData->SetTestType(CTestData::EGetSearchKeys);

  1046 		//Create the login object

  1047 		iLoginObj = CTelepathyGabbleLoginTest::NewL();

  1048 		

  1049 		//action_login will have parameters 

  1050 		//passed from cfg file

  1051 		

  1052 		TInt login_status = 

  1053 			iLoginObj->action_login(username,passwd,servername, 

  1054 									resource_login,ssl_flag,

  1055 									port,proxy_server, proxy_port,

  1056 									iTestData );

  1057 		

  1058 		if (login_status == CTestData::ECONNECTED)

  1059 		{

  1060 			//login was successful

  1061 			//Create the Object of Send Message class

  1062 			iSearchObj = CTelepathyGabbleSearch::NewL();

  1063 				

  1064 			TInt search_state = iSearchObj->GetSearchKeysL( iTestData);

  1065 			

  1066 			if( search_state == CTestData::ESearchError )

  1067 				{

  1068 					return_value = KErrGeneral; //Error in finding search keys

  1069 				}

  1070 			else if( search_state == CTestData::ESearchKeysFound) 

  1071 				{

  1072 					return_value = KErrNone; 

  1073 					

  1074 					GHashTable *data_to_search = NULL;				

  1075 					data_to_search = g_hash_table_new(g_str_hash,g_str_equal);

  1076 					gchar **keys = iTestData->GetSearchKeys();

  1077 				

  1078 					iTestData->SetTestType(CTestData::ESearch);

  1079 					for(TInt i=0; i<8 ; i++ )

  1080 						{

  1081 							GValue *gvalue = NULL;

  1082 							gvalue = g_new0(GValue, 1);	

  1083 						

  1084 							g_value_init(gvalue, G_TYPE_STRING);

  1085 							g_value_set_string (gvalue, g_strdup(value) );

  1086 							g_hash_table_insert( data_to_search,keys[i], gvalue);	

  1087 							

  1088 						}

  1089 					

  1090 					search_state = iSearchObj->SearchL(data_to_search, iTestData);

  1091 			

  1092 					if( search_state == CTestData::ESearchError )

  1093 						{

  1094 							return_value = KErrGeneral; //Error in Searching

  1095 						}

  1096 					else if( search_state == CTestData::ESearchCompleted) 

  1097 						{

  1098 							return_value = KErrNone; 

  1099 						}

  1100 					//Free the hash table itself

  1101 					g_hash_table_destroy ( data_to_search );

  1102 					

  1103 

  1104 				}

  1105 			iSearchObj->CloseChannel(iTestData);

  1106 			//Do the logout

  1107 			login_status = iLoginObj->action_logout(iTestData);

  1108 

  1109 			if (login_status != CTestData::EDISCONNECTED)

  1110 				{

  1111 					//logout didnot happen successfully

  1112 					return_value = KErrGeneral;

  1113 				}

  1114 			

  1115 			//do this later	

  1116 		   	/*g_hash_table_foreach_remove ( data_to_search, 

  1117 					search_hash_remove, NULL );*/

  1118 		

  1119 		}

  1120 		else

  1121 		{

  1122 			//Login itself didnot happen.

  1123 			return_value =  KErrGeneral;

  1124 		}		

  1125 		

  1126 		free_data ( connect_data, iLog );	

  1127 		return return_value;

  1128 	}

  1129 	

  1130 

  1131 

  1132 // -----------------------------------------------------------------------------

  1133 // CTelepathyGabbleTest::SearchWithAllKeysTestL

  1134 // -----------------------------------------------------------------------------

  1135