/*

* Copyright (c) 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 FILES] - do not remove    

#include <e32std.h>

#include <e32svr.h>

#include <StifParser.h>

#include <Stiftestinterface.h> 

#include <unistd.h>

#include "stif_1.h"

#include <sys/stat.h>

#include <pthread.h>

#include <fcntl.h>

#include <string.h>

#include <spawn.h>

#include "errno.h"

#define MAX_THREAD 25

#define MAX_SIGNALS 3

#define MAX_CONN 21

#define MAX_CONN_EXE 25

_LIT(KSuccess, "Test Successful");

_LIT(KOOM, "Out Of Memory");

int var_arg_ret_val = -3;

int pending_call_ret_val = -6;

TBool data_free_flag = FALSE;

struct TestData

{

	int num;

	char* str;

};

struct TestData1

{

	int data_slot;

	TestData* data;

};

void Free_Test_Data(void* data)

	{

		TestData* test_data;

		test_data = (TestData*)data;

		free(test_data->str);

		free(test_data);

		data_free_flag = TRUE;

	}

void handle_reply_variable_args(DBusPendingCall* pending, void* data)

	{

		DBusMessage* msg1;

		DBusMessageIter return_iter;

		DBusError error;

		dbus_int32_t* return_value = (dbus_int32_t*)data;

		dbus_int32_t ret;

		// get the reply message

		msg1 = dbus_pending_call_steal_reply(pending);

		if (NULL == msg1) {

		*return_value = -2; 

		}

		// free the pending message handle

		dbus_pending_call_unref(pending);

		dbus_error_init (&error);

		dbus_message_iter_init(msg1, &return_iter);

		dbus_message_iter_get_basic(&return_iter, return_value);

		ret = *return_value; 

		RDebug::Printf("return value is:%d\n", ret);

		dbus_message_unref(msg1);  

	}

void handle_reply_pending_call_data_slot0(DBusPendingCall* pending, void* data)

	{

		DBusMessage* msg1;

		DBusError error;

		int return_value;

		TestData1* data1 = (TestData1*)data;

		TestData* test_data;

		TestData* new_data;

		DBusFreeFunction free_data;

		// get the reply message

		msg1 = dbus_pending_call_steal_reply(pending);

		if (NULL == msg1) {

		return_value = -2; 

		return;

		}		

		dbus_error_init (&error);

		dbus_message_get_args(msg1, &error, DBUS_TYPE_INT32, &return_value, DBUS_TYPE_INVALID);

		if(return_value == 9090)

			return_value = 0;

		test_data = (TestData*)dbus_pending_call_get_data(pending, data1->data_slot);

		if(test_data->num != data1->data->num || strcmp(test_data->str, data1->data->str))

			{

			return_value = -3;

			return;

			}

		new_data = (TestData *)malloc(sizeof(TestData));

		new_data->num = 234;

		new_data->str = (char*)malloc(20);

		strcpy(new_data->str, "Check DBus New");

		free_data = Free_Test_Data;

		data_free_flag = FALSE;

		if(!dbus_pending_call_set_data(pending, data1->data_slot, new_data, free_data))

			{

			return_value = -4; 

			return;

			}

		if(!data_free_flag)

			{

			return_value = -5;

			return;

			}

		data_free_flag = FALSE;

		pending_call_ret_val = return_value;

		dbus_message_unref(msg1);  

		// free the pending message handle

		dbus_pending_call_unref(pending);

	}

void free_mem(void* data)

	{

	dbus_int32_t* return_value = (dbus_int32_t*)data;

	var_arg_ret_val = *return_value;

	free(data);

	}

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

int Cstif_1::handle_error(DBusError* error)

	{

	iLog->Log(_L8("%s"), error->name);

	iLog->Log(_L8("%s"), error->message);

	dbus_error_free(error);

	return 1; 

	} 

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

// Cstif_1::Delete

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

// Called from destructor. 

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

//

void Cstif_1::Delete() 

    {

    }

TBool TestConnectionEqual(DBusConnection* conn1, DBusConnection* conn2)

	{

		return (conn1==conn2? TRUE : FALSE);

	}

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

// Cstif_1::RunMethodL

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

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

//

TInt Cstif_1::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const KFunctions[] =

        {  

        // Copy this line for every implemented function.

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

        // Second is the actual implementation member function. 

        ENTRY( "stif_Test_Names", Cstif_1::stif_Test_Names ),

		ENTRY( "stif_Method_Call", Cstif_1::stif_Method_Call ),

        ENTRY( "stif_N_Connections", Cstif_1::stif_N_Connections ),

        ENTRY( "stif_Variable_Args", Cstif_1::stif_Variable_Args ),

        ENTRY( "stif_N_Messages", Cstif_1::stif_N_Messages ),

        ENTRY( "stif_N_Messages1", Cstif_1::stif_N_Messages1 ),

        ENTRY( "stif_Signal", Cstif_1::stif_Signal ),

        ENTRY( "stif_File_Send", Cstif_1::stif_File_Send ),

        ENTRY( "stif_File_Send_Whole", Cstif_1::stif_File_Send_Whole ),

        ENTRY( "stif_Match_Rule", Cstif_1::stif_Match_Rule ),

        ENTRY( "stif_Sign_Test", Cstif_1::stif_Sign_Test ),

        ENTRY( "stif_N_Separate_Connections", Cstif_1::stif_N_Separate_Connections ),

        ENTRY( "stif_Pending_Call_Data_Slot0", Cstif_1::stif_Pending_Call_Data_Slot0),   

        ENTRY( "stif_Time0", Cstif_1::stif_Time0),

        ENTRY( "stif_Simultaneous_Connections", Cstif_1::stif_Simultaneous_Connections),

        ENTRY( "stif_Daemon_Run_Time0", Cstif_1::stif_Daemon_Run_Time0)

        //ADD NEW ENTRY HERE

        // [test cases entries] - Do not remove

        }; 

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

void Cstif_1::TestName(DBusConnection *connection, const char *name, int expectedSuccess, int* result)

{

  	DBusError error;

  	dbus_error_init (&error);

  	(void) dbus_bus_request_name (connection, name, 0, &error);

  	if (dbus_error_is_set (&error))

    {

    	if (expectedSuccess)

    	{

    		iLog->Log(_L8("Error acquiring name '%s': %s\n"), name, error.message);

    		*result = 1;

    	}

    	else

   		{

   			iLog->Log(_L8("Expected Error acquiring name '%s': %s\n"), name, error.message);

   			*result = 1;

   		}

    	dbus_error_free (&error);

    }

  	else 

    {

    	if (!expectedSuccess)

    	{

    		iLog->Log(_L8("Unexpected Success acquiring name '%s'\n"), name);

    		*result = 1;

    	}

    	else

    		iLog->Log(_L8("Successfully acquired name '%s'\n"), name);

    }

}

TInt Cstif_1::stif_Test_Names( CStifItemParser& aItem )

{

TestModuleIf().SetBehavior( CTestModuleIf::ETestLeaksRequests ); 

TestModuleIf().SetBehavior( CTestModuleIf::ETestLeaksHandles );  

	DBusError error;

	DBusConnection *connection;

	int result = 0;

	dbus_error_init (&error);

	connection = dbus_bus_get_private (DBUS_BUS_SESSION, &error);

	if (connection == NULL)

	  {

	  			iLog->Log(_L8("*** Failed to open connection to system bus: %s\n%s"),  error.name, error.message);

	    dbus_error_free (&error);

	    return 1;

	  }

	TestName(connection, "org.freedesktop.DBus.Test", TRUE, &result);

	TestName(connection, "org.freedesktop.DBus.Test-2", TRUE, &result);

	TestName(connection, "org.freedesktop.DBus.Test_2", TRUE, &result);

	#if 0

	TestName(connection, "Test_2", TRUE, &result);

	#endif

	if(result)

		return 1;

	dbus_connection_close(connection);

	dbus_connection_unref(connection);

	dbus_shutdown();

	iLog->Log(KSuccess);

	return KErrNone;

}

TInt Cstif_1::stif_Method_Call( CStifItemParser& aItem )

    { 

    TestModuleIf().SetBehavior( CTestModuleIf::ETestLeaksRequests ); 

    TestModuleIf().SetBehavior( CTestModuleIf::ETestLeaksHandles ); 

    __UHEAP_MARK;

    _LIT(KStart, "Test Start");

	    DBusError error; 

		DBusConnection* connection;

		DBusMessage* msg;

		DBusMessageIter args;

		DBusMessageIter append_args;

		//~!@#$%^&*()_  . hjgfyh34348#$!%^4567

		char* str = "DBus Testing";

		char* str1;

		int i;

		DBusPendingCall* pending; 

		iLog->Log(KStart);

		dbus_error_init(&error); 

		iLog->Log(_L8("creating connection"));	

		connection = dbus_bus_get_private(DBUS_BUS_SESSION, &error);

		if(dbus_error_is_set(&error))

			return handle_error(&error);

		iLog->Log(_L8("connection created successfully"));

		msg = dbus_message_new_method_call("Test.Method.Call", "/Test/Method/Object", NULL, "method");

		if(msg == NULL)

			{

			iLog->Log(_L8("message error")); 

			return 1;

			}

		iLog->Log(_L8("message created successfully"));

		dbus_message_iter_init_append(msg, &append_args);

		for(i=0;i<255;i++)

		{

			if(!dbus_message_iter_append_basic(&append_args, DBUS_TYPE_STRING, &str))

			{

				iLog->Log(_L8("Unable to append arguments. msg no. %d"));

				return 1; 

			} 

		}	   

		// send message and get a handle for a reply

	   if (!dbus_connection_send_with_reply (connection, msg, &pending, -1)) { // -1 is default timeout

	   		iLog->Log(_L8("message send error"));

	   		exit(1);

	   } 

	   if (NULL == pending) { 

	   		iLog->Log(_L8("pending is null"));

	      exit(1); 

	   } 

	   dbus_connection_flush(connection);

		// free message

	   dbus_message_unref(msg);

	   // block until we recieve a reply

	   dbus_pending_call_block(pending);

	   // get the reply message

	   msg = dbus_pending_call_steal_reply(pending);

	   if (NULL == msg) {

	   iLog->Log(_L8("Reply error"));	   		

	      return 1;

	   } 

	   // free the pending message handle

	   dbus_pending_call_unref(pending);

		dbus_error_init (&error);

		dbus_message_iter_init(msg, &args);

		i=1; 

		do{

			dbus_message_iter_get_basic(&args, &str1);

			iLog->Log(_L8("%d th Reply = %s"), i, str1);

			if(strcmp(str, str1)) 

				   {

				   iLog->Log(_L8("Invalid reply error"));

				   return 1;

				   }

			i++;

		}while(dbus_message_iter_next(&args)); 

	   // free reply and close connection

	   dbus_message_unref(msg);  

	   dbus_connection_close(connection);

	   dbus_connection_unref(connection);

	   dbus_shutdown();

	   iLog->Log( KSuccess );

	   __UHEAP_MARKEND;

	   return KErrNone;

    }

// Currently 21 connections are created If tried more will failed to get connection

TInt Cstif_1::stif_N_Connections( CStifItemParser& aItem )

	{

//		__UHEAP_MARK;

	TestModuleIf().SetBehavior( CTestModuleIf::ETestLeaksRequests ); 

    TestModuleIf().SetBehavior( CTestModuleIf::ETestLeaksHandles ); 

 		DBusConnection* connection[MAX_CONN];

		DBusError error;

		int cnt=0;

		int cnt1=0;

		dbus_error_init(&error);

		for(cnt=0;cnt<MAX_CONN;cnt++)

		{

			connection[cnt] = dbus_bus_get_private(DBUS_BUS_SESSION, &error);

			if(!connection[cnt] || dbus_error_is_set(&error))

			{

				iLog->Log(_L8("Error_name = %s"), error.name);

				iLog->Log(_L8("Error_msg = %s"), error.message);

				break;

			}

			else

			{

				for(cnt1=0;cnt1<cnt;cnt1++)

				{

					if(TestConnectionEqual(connection[cnt], connection[cnt1]))

					{ 

						iLog->Log(_L8("%d and %d Connections are equal."), cnt, cnt1);

						dbus_connection_close(connection[cnt]);

						dbus_connection_unref(connection[cnt]);

						break;

					}

				}

				iLog->Log(_L8("Connection Success %d"), cnt);

			}

		} 

		for(cnt1=0;cnt1<cnt;cnt1++)

			{

			dbus_connection_close(connection[cnt1]);

			dbus_connection_unref(connection[cnt1]);

			}

		dbus_shutdown();

		if(cnt!=MAX_CONN)

			return 1;

		iLog->Log(KSuccess);

//		__UHEAP_MARKEND;

		return KErrNone;

	}

TInt Cstif_1::stif_Variable_Args( CStifItemParser& aItem )

	{

	TestModuleIf().SetBehavior( CTestModuleIf::ETestLeaksRequests ); 

    TestModuleIf().SetBehavior( CTestModuleIf::ETestLeaksHandles );  

		_LIT(KOOM, "Out Of Memory");

		DBusConnection* connection;

		DBusError error;

		DBusMessage* msg;

		DBusMessageIter append_iter;

		DBusMessageIter sub_iter;

		DBusPendingCall* pending;

		dbus_bool_t arg_bool = TRUE;

		dbus_int16_t arg_int16 = -16;

		dbus_int32_t arg_int32 = -32;

		dbus_int64_t arg_int64 = -64;

		dbus_uint16_t arg_uint16 = 16;

		dbus_uint32_t arg_uint32 = 32;

		dbus_uint64_t arg_uint64 = 64;

		double arg_double = 12.34567;

		char* arg_str = "DBus Testing";

		const dbus_int32_t array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

		const dbus_int32_t *arr = array;

		DBusPendingCallNotifyFunction reply_handler;

		DBusFreeFunction free_data;

		dbus_int32_t* return_value;

		dbus_error_init(&error); 

		connection = dbus_bus_get_private(DBUS_BUS_SESSION, &error);

		if(!connection)

			return handle_error(&error);

		msg = dbus_message_new_method_call("Test.Method.Call", "/Test/Method/Object", "test.Method.Call", "variable_args_method");

		if(msg == NULL)

			{ 

			iLog->Log(_L8("message error"));

			return 1;

			}

		iLog->Log(_L8("message created successfully"));

		dbus_message_iter_init_append(msg, &append_iter);

		if(!dbus_message_iter_append_basic(&append_iter, DBUS_TYPE_BOOLEAN, &arg_bool))

			{ 

			iLog->Log(KOOM);

			return 1; 

			} 

		if(!dbus_message_iter_append_basic(&append_iter, DBUS_TYPE_INT16, &arg_int16))

			{

			iLog->Log(KOOM);

			return 1;

			}

		if(!dbus_message_iter_append_basic(&append_iter, DBUS_TYPE_INT32, &arg_int32))

			{

			iLog->Log(KOOM);

			return 1;

			}

		if(!dbus_message_iter_append_basic(&append_iter, DBUS_TYPE_INT64, &arg_int64))

			{

			iLog->Log(KOOM);

			return 1;

			}

		if(!dbus_message_iter_append_basic(&append_iter, DBUS_TYPE_UINT16, &arg_uint16))

			{

			iLog->Log(KOOM);