Return-Path: 
 <axis-cvs-return-5788-apmail-ws-axis-dev-archive=ws.apache.org@ws.apache.org>
Delivered-To: apmail-ws-axis-dev-archive@www.apache.org
Received: (qmail 18110 invoked from network); 11 Mar 2005 04:58:40 -0000
Received: from hermes.apache.org (HELO mail.apache.org) (209.237.227.199)
  by minotaur-2.apache.org with SMTP; 11 Mar 2005 04:58:40 -0000
Received: (qmail 60392 invoked by uid 500); 11 Mar 2005 04:58:39 -0000
Delivered-To: apmail-ws-axis-dev-archive@ws.apache.org
Received: (qmail 60073 invoked by uid 500); 11 Mar 2005 04:58:38 -0000
Mailing-List: contact axis-cvs-help@ws.apache.org; run by ezmlm
Precedence: bulk
list-help: <mailto:axis-cvs-help@ws.apache.org>
list-unsubscribe: <mailto:axis-cvs-unsubscribe@ws.apache.org>
List-Post: <mailto:axis-cvs@ws.apache.org>
Delivered-To: mailing list axis-cvs@ws.apache.org
Received: (qmail 60059 invoked by uid 99); 11 Mar 2005 04:58:38 -0000
X-ASF-Spam-Status: No, hits=-9.3 required=10.0
	tests=ALL_TRUSTED,NO_REAL_NAME,WEIRD_PORT
X-Spam-Check-By: apache.org
Received: from minotaur.apache.org (HELO minotaur.apache.org)
 (209.237.227.194)
  by apache.org (qpsmtpd/0.28) with SMTP; Thu, 10 Mar 2005 20:58:37 -0800
Received: (qmail 18054 invoked by uid 2003); 11 Mar 2005 04:58:36 -0000
Date: 11 Mar 2005 04:58:36 -0000
Message-ID: <20050311045836.18053.qmail@minotaur.apache.org>
From: jamejose@apache.org
To: ws-axis-cvs@apache.org
Subject: cvs commit: ws-axis/c/tests/auto_build/testcases/client/cpp
 SimpleTypeInnerUnbounded_TTestClient.cpp SimpleRefDoc_TTestClient.cpp
 XSDTime_TTestClient.cpp SimpleTypeArray_TTestClient.cpp
 AxisBench_TTestClient.cpp SimpleTypeInnerUnboundedInOutput_TTestClient.cpp
X-Virus-Checked: Checked
X-Spam-Rating: minotaur-2.apache.org 1.6.2 0/1000/N

jamejose    2005/03/10 20:58:36

  Added:       c/tests/auto_build/testcases/client/cpp
                        SimpleTypeInnerUnbounded_TTestClient.cpp
                        SimpleRefDoc_TTestClient.cpp
                        XSDTime_TTestClient.cpp
                        SimpleTypeArray_TTestClient.cpp
                        AxisBench_TTestClient.cpp
                        SimpleTypeInnerUnboundedInOutput_TTestClient.cpp
  Log:
  
  
  Revision  Changes    Path
  1.1                  ws-axis/c/tests/auto_build/testcases/client/cpp/SimpleTypeInnerUnbounded_TTestClient.cpp
  
  Index: SimpleTypeInnerUnbounded_TTestClient.cpp
  ===================================================================
  
  /* This program will create 10 Threads and each thread will invoke SimpleTypeInnerUnbounded Service 
     @Author James
  */
  
  #include "SimpleTypeInnerUnboundedWS.hpp"
  #include <axis/AxisException.hpp>
  //#include <exception>
  #include <ctype.h>
  #include <iostream>
  #include <stdlib.h>
  #include <axis/Axis.hpp>
  /* Defining platform specific constants  */
  #ifdef WIN32
          #include <windows.h>
          #define RETTYPE DWORD WINAPI
          #define ARGTYPE LPVOID
  #else
          #include <pthread.h>
          #include <unistd.h>
          #define RETTYPE void*
          #define ARGTYPE void*
  #endif
  
  
  //#define MACRO_NUM_THREADS 10
  //int NUM_THREADS = MACRO_NUM_THREADS;
  #define NUM_THREADS 10
  
  
  /* In windows the entry point function return type is DWORD WINAPI
     In linux it is void *                                          */
  RETTYPE ThreadFunc(ARGTYPE Param)
  {
          /*Type casting the url to char * */
          char *p=(char *)Param;
          char endpoint[256];
          const char* url="http://localhost:9080/SimpleTypeInnerUnbounded/services/sampleWS";
          if(p!=NULL)
               url=p;
  		SimpleTypeInnerUnboundedWS *ws;
          try
          {
              sprintf(endpoint, "%s", url);
              ws= new   SimpleTypeInnerUnboundedWS(endpoint, APTHTTP1_1);
  			Type1 *input =  new Type1();
  			Type1* result;
  			char *idents[10];
  			int i;
  
  			input->enum_int = ENUMTYPEINT_1;
  			input->enum_string = strdup("one");
  			input->att_enum_kind = strdup("CHEQUE");
  			input->att_enum_string = strdup("one");
  			input->att_enum_int = ENUMTYPEINT_1;
  
  			input->ident.m_Array = idents;
  			input->ident.m_Size = 10;
  			for ( i = 0; i < 10; i++ ) {
  			idents[i] = strdup ("Hello world");
  			}
  
  			result = ws->getInput(input);
  			if ( result == NULL )
  				cout << "NULL" << endl;
  			else {
  				cout << "att_enum_int " << result->att_enum_int << endl;		
  				
            }
  			delete ws;
  		}catch(AxisException& e)
          {
              cout << "Exception : " << e.what() << endl;
          }
          catch(exception& e)
          {
              cout << "Unknown exception has occured" << endl;
          }
          catch(...)
          {
              cout << "Unknown exception has occured" << endl;
          }
                  #ifndef WIN32
                          pthread_exit(0);
                  #endif
          return 0;
  }
  
  
  
  
  int main(int argc, char *argv[])
  {
      Axis::initialize(false);
  	try{
  		 int i;
  		 #ifdef WIN32
  			/*Windows specific code comes here */
  			HANDLE hThread[NUM_THREADS];
  			for(i=0;i<NUM_THREADS;i++){
  					DWORD dwThreadId;
  					//LPVOID dwThrdParam = LPVOID(argv[1]);
  					hThread[i] = CreateThread(
  											NULL,                        // no security attributes
  											0,                           // use default stack size
  											ThreadFunc,                  // thread function
  											LPVOID(argv[1]),             // argument to thread function
  											0,   
  										&dwThreadId);              // returns the thread identifier
  
  			if (hThread[i] == NULL)
  			{
  			cout<<"Thread creation Failed";
  			}
  			}
  			/* Waiting for threads to terminate */
  			WaitForMultipleObjects(NUM_THREADS,hThread,true, INFINITE);
  			for(i=0;i<NUM_THREADS;i++)
  					CloseHandle( hThread[i] );
  
  		#else	
  			pthread_t thread[NUM_THREADS];
  			pthread_attr_t attr;
  			int rc, t, status = 0;
  		//   Initialize and set thread detached attribute
  			pthread_attr_init(&attr);
  			pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
  			for (t = 0; t < NUM_THREADS; t++)
  			{
  			/*Creating threads */
  				rc = pthread_create(&thread[t], &attr, ThreadFunc,(void *)argv[1]);
  				if (rc)
  				{
  					cout<<"Thread Creation Failed";
  				}
  			}
  		//Free attribute and wait for the other threads
  		pthread_attr_destroy(&attr);
  		/* Wait for the threads to terminate  */
  		for(t=0;t<NUM_THREADS;t++){
  			rc = pthread_join(thread[t], (void **)&status);
  				if (rc)
  				{
  					cout<<"ERROR from pthread_join()"<<endl;
  				}
  		}
  	#endif
    }catch(exception &e){
             cout<< e.what();
    }
    cout<<endl <<"----------------------------------TEST COMPLETE--------------------------------"<<endl;
  }
  
  
  
  
  1.1                  ws-axis/c/tests/auto_build/testcases/client/cpp/SimpleRefDoc_TTestClient.cpp
  
  Index: SimpleRefDoc_TTestClient.cpp
  ===================================================================
  
  /* This program will create 10 Threads and each thread will invoke SimpleRef Service 
     @Author James
  */
  
  #include "RefTestPortType.hpp"
  #include <axis/AxisException.hpp>
  //#include <exception>
  #include <ctype.h>
  #include <iostream>
  #include <stdlib.h>
  #include <axis/Axis.hpp>
  /* Defining platform specific constants  */
  #ifdef WIN32
          #include <windows.h>
          #define RETTYPE DWORD WINAPI
          #define ARGTYPE LPVOID
  #else
          #include <pthread.h>
          #include <unistd.h>
          #define RETTYPE void*
          #define ARGTYPE void*
  #endif
  
  
  //#define MACRO_NUM_THREADS 10
  //int NUM_THREADS = MACRO_NUM_THREADS;
  #define NUM_THREADS 10
  
  
  /* In windows the entry point function return type is DWORD WINAPI
     In linux it is void *                                          */
  RETTYPE ThreadFunc(ARGTYPE Param)
  {
          /*Type casting the url to char * */
          char *p=(char *)Param;
          char endpoint[256];
          const char* url="http://puppet.in.ibm.com:9060/Calculator/services/Calculator";
          if(p!=NULL)
               url=p;
          try
          {
                  sprintf(endpoint, "%s", url);
  				RefTestPortType ws(endpoint);
  				IntType refint;
  				refint.intItem =56;
  				if ((ws.echoInt(&refint))->intItem == 56)
  				{
  					cout << "successful"<<endl;
  				}
  				else
  				{
  					cout << "failed "<<endl;
  				}
  
          }
          catch(AxisException& e)
          {
              cout << "Exception : " << e.what() << endl;
          }
          catch(exception& e)
          {
              cout << "Unknown exception has occured" << endl;
          }
          catch(...)
          {
              cout << "Unknown exception has occured" << endl;
          }
                  #ifndef WIN32
                          pthread_exit(0);
                  #endif
          return 0;
  }
  
  
  
  
  int main(int argc, char *argv[])
  {
      Axis::initialize(false);
  	try{
  		 int i;
  		 #ifdef WIN32
  			/*Windows specific code comes here */
  			HANDLE hThread[NUM_THREADS];
  			for(i=0;i<NUM_THREADS;i++){
  					DWORD dwThreadId;
  					//LPVOID dwThrdParam = LPVOID(argv[1]);
  					hThread[i] = CreateThread(
  											NULL,                        // no security attributes
  											0,                           // use default stack size
  											ThreadFunc,                  // thread function
  											LPVOID(argv[1]),             // argument to thread function
  											0,   
  										&dwThreadId);              // returns the thread identifier
  
  			if (hThread[i] == NULL)
  			{
  			cout<<"Thread creation Failed";
  			}
  			}
  			/* Waiting for threads to terminate */
  			WaitForMultipleObjects(NUM_THREADS,hThread,true, INFINITE);
  			for(i=0;i<NUM_THREADS;i++)
  					CloseHandle( hThread[i] );
  
  		#else	
  			pthread_t thread[NUM_THREADS];
  			pthread_attr_t attr;
  			int rc, t, status = 0;
  		//   Initialize and set thread detached attribute
  			pthread_attr_init(&attr);
  			pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
  			for (t = 0; t < NUM_THREADS; t++)
  			{
  			/*Creating threads */
  				rc = pthread_create(&thread[t], &attr, ThreadFunc,(void *)argv[1]);
  				if (rc)
  				{
  					cout<<"Thread Creation Failed";
  				}
  			}
  		//Free attribute and wait for the other threads
  		pthread_attr_destroy(&attr);
  		/* Wait for the threads to terminate  */
  		for(t=0;t<NUM_THREADS;t++){
  			rc = pthread_join(thread[t], (void **)&status);
  				if (rc)
  				{
  					cout<<"ERROR from pthread_join()"<<endl;
  				}
  		}
  	#endif
    }catch(exception &e){
             cout<< e.what();
    }
    cout<<endl <<"----------------------------------TEST COMPLETE--------------------------------"<<endl;
  }
  
  
  
  
  1.1                  ws-axis/c/tests/auto_build/testcases/client/cpp/XSDTime_TTestClient.cpp
  
  Index: XSDTime_TTestClient.cpp
  ===================================================================
  
  /* This program will create 10 Threads and each thread will invoke XSDTime Service 
     @Author James
  */
  
  #include "XSDElement.hpp"
  #include <axis/AxisException.hpp>
  //#include <exception>
  #include <ctype.h>
  #include <iostream>
  #include <stdlib.h>
  #include <axis/Axis.hpp>
  /* Defining platform specific constants  */
  #ifdef WIN32
          #include <windows.h>
          #define RETTYPE DWORD WINAPI
          #define ARGTYPE LPVOID
  #else
          #include <pthread.h>
          #include <unistd.h>
          #define RETTYPE void*
          #define ARGTYPE void*
  #endif
  
  
  //#define MACRO_NUM_THREADS 10
  //int NUM_THREADS = MACRO_NUM_THREADS;
  #define NUM_THREADS 10
  
  
  /* In windows the entry point function return type is DWORD WINAPI
     In linux it is void *                                          */
  RETTYPE ThreadFunc(ARGTYPE Param)
  {
          /*Type casting the url to char * */
          char *p=(char *)Param;
          char endpoint[256];
          const char* url="http://puppet.in.ibm.com:9060/XSDElement/services/XSDElementPort";
          if(p!=NULL)
               url=p;
  		char dateTime[50];
  		xsd__time timeResult;           // typedef of struct tm
  		time_t timeToTest;
  		timeToTest = 1100246323;
  		xsd__date *temp = gmtime(&timeToTest);
  		xsd__date testDate;
  		memcpy(&testDate, temp, sizeof(xsd__date));
  
  		try
  		{
  			sprintf(endpoint, "%s", url);
  			XSDElement* ws = new XSDElement(endpoint);
  			timeResult = ws->setGetTimeType(testDate);
  			strftime(dateTime, 50, "%H:%M:%S", &timeResult);
  			cout << "time=" << dateTime << endl;
  			delete ws;
  		}
          catch(AxisException& e)
          {
              cout << "Exception : " << e.what() << endl;
          }
          catch(exception& e)
          {
              cout << "Unknown exception has occured" << endl;
          }
          catch(...)
          {
              cout << "Unknown exception has occured" << endl;
          }
                  #ifndef WIN32
                          pthread_exit(0);
                  #endif
          return 0;
  }
  
  
  
  
  int main(int argc, char *argv[])
  {
      Axis::initialize(false);
  	try{
  		 int i;
  		 #ifdef WIN32
  			/*Windows specific code comes here */
  			HANDLE hThread[NUM_THREADS];
  			for(i=0;i<NUM_THREADS;i++){
  					DWORD dwThreadId;
  					//LPVOID dwThrdParam = LPVOID(argv[1]);
  					hThread[i] = CreateThread(
  											NULL,                        // no security attributes
  											0,                           // use default stack size
  											ThreadFunc,                  // thread function
  											LPVOID(argv[1]),             // argument to thread function
  											0,   
  										&dwThreadId);              // returns the thread identifier
  
  			if (hThread[i] == NULL)
  			{
  			cout<<"Thread creation Failed";
  			}
  			}
  			/* Waiting for threads to terminate */
  			WaitForMultipleObjects(NUM_THREADS,hThread,true, INFINITE);
  			for(i=0;i<NUM_THREADS;i++)
  					CloseHandle( hThread[i] );
  
  		#else	
  			pthread_t thread[NUM_THREADS];
  			pthread_attr_t attr;
  			int rc, t, status = 0;
  		//   Initialize and set thread detached attribute
  			pthread_attr_init(&attr);
  			pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
  			for (t = 0; t < NUM_THREADS; t++)
  			{
  			/*Creating threads */
  				rc = pthread_create(&thread[t], &attr, ThreadFunc,(void *)argv[1]);
  				if (rc)
  				{
  					cout<<"Thread Creation Failed";
  				}
  			}
  		//Free attribute and wait for the other threads
  		pthread_attr_destroy(&attr);
  		/* Wait for the threads to terminate  */
  		for(t=0;t<NUM_THREADS;t++){
  			rc = pthread_join(thread[t], (void **)&status);
  				if (rc)
  				{
  					cout<<"ERROR from pthread_join()"<<endl;
  				}
  		}
  	#endif
    }catch(exception &e){
             cout<< e.what();
    }
    cout<<endl <<"----------------------------------TEST COMPLETE--------------------------------"<<endl;
  }
  
  
  
  
  1.1                  ws-axis/c/tests/auto_build/testcases/client/cpp/SimpleTypeArray_TTestClient.cpp
  
  Index: SimpleTypeArray_TTestClient.cpp
  ===================================================================
  
  /* This program will create 10 Threads and each thread will invoke SimpleTypeArray Service 
     @Author James
  */
  
  #include "SimpleTypeArrayWS.hpp"
  #include <axis/AxisException.hpp>
  //#include <exception>
  #include <ctype.h>
  #include <iostream>
  #include <stdlib.h>
  #include <axis/Axis.hpp>
  /* Defining platform specific constants  */
  #ifdef WIN32
          #include <windows.h>
          #define RETTYPE DWORD WINAPI
          #define ARGTYPE LPVOID
  #else
          #include <pthread.h>
          #include <unistd.h>
          #define RETTYPE void*
          #define ARGTYPE void*
  #endif
  
  
  //#define MACRO_NUM_THREADS 10
  //int NUM_THREADS = MACRO_NUM_THREADS;
  #define NUM_THREADS 10
  
  
  /* In windows the entry point function return type is DWORD WINAPI
     In linux it is void *                                          */
  RETTYPE ThreadFunc(ARGTYPE Param)
  {
          /*Type casting the url to char * */
          char *p=(char *)Param;
          char endpoint[256];
          const char* url="http://localhost:9080/SimpleTypeArray/services/sampleWS";
          if(p!=NULL)
               url=p;
            SimpleTypeArrayWS *ws;
          try
          {
                  sprintf(endpoint, "%s", url);
                  ws=new SimpleTypeArrayWS(endpoint, APTHTTP1_1);
                  Type *input;
  				Type *output;
  				xsd__int_Array array_input;
  				int entries[100];
  				int i;
  
  				array_input.m_Array = entries;
  				array_input.m_Size  = 100;
  
  				for ( i = 0; i < 100; i++ ) {
  				entries[i] = i;
  				}
  
  				input = new Type();
  				input->item = array_input;
  
  				output = ws->getInput(input);
  				i=0;				
  				cout << "item [" << i << "] = " << output->item.m_Array[i] << endl;			
  				delete ws;
          }
          catch(AxisException& e)
          {
              cout << "Exception : " << e.what() << endl;
          }
          catch(exception& e)
          {
              cout << "Unknown exception has occured" << endl;
          }
          catch(...)
          {
              cout << "Unknown exception has occured" << endl;
          }
                  #ifndef WIN32
                          pthread_exit(0);
                  #endif
          return 0;
  }
  
  
  
  
  int main(int argc, char *argv[])
  {
      Axis::initialize(false);
  	try{
  		 int i;
  		 #ifdef WIN32
  			/*Windows specific code comes here */
  			HANDLE hThread[NUM_THREADS];
  			for(i=0;i<NUM_THREADS;i++){
  					DWORD dwThreadId;
  					//LPVOID dwThrdParam = LPVOID(argv[1]);
  					hThread[i] = CreateThread(
  											NULL,                        // no security attributes
  											0,                           // use default stack size
  											ThreadFunc,                  // thread function
  											LPVOID(argv[1]),             // argument to thread function
  											0,   
  										&dwThreadId);              // returns the thread identifier
  
  			if (hThread[i] == NULL)
  			{
  			cout<<"Thread creation Failed";
  			}
  			}
  			/* Waiting for threads to terminate */
  			WaitForMultipleObjects(NUM_THREADS,hThread,true, INFINITE);
  			for(i=0;i<NUM_THREADS;i++)
  					CloseHandle( hThread[i] );
  
  		#else	
  			pthread_t thread[NUM_THREADS];
  			pthread_attr_t attr;
  			int rc, t, status = 0;
  		//   Initialize and set thread detached attribute
  			pthread_attr_init(&attr);
  			pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
  			for (t = 0; t < NUM_THREADS; t++)
  			{
  			/*Creating threads */
  				rc = pthread_create(&thread[t], &attr, ThreadFunc,(void *)argv[1]);
  				if (rc)
  				{
  					cout<<"Thread Creation Failed";
  				}
  			}
  		//Free attribute and wait for the other threads
  		pthread_attr_destroy(&attr);
  		/* Wait for the threads to terminate  */
  		for(t=0;t<NUM_THREADS;t++){
  			rc = pthread_join(thread[t], (void **)&status);
  				if (rc)
  				{
  					cout<<"ERROR from pthread_join()"<<endl;
  				}
  		}
  	#endif
    }catch(exception &e){
             cout<< e.what();
    }
    cout<<endl <<"----------------------------------TEST COMPLETE--------------------------------"<<endl;
  }
  
  
  
  
  1.1                  ws-axis/c/tests/auto_build/testcases/client/cpp/AxisBench_TTestClient.cpp
  
  Index: AxisBench_TTestClient.cpp
  ===================================================================
  
  /* This program will create 10 Threads and each thread will invoke AxisBench Service 
     @Author James
  */
  
  #include "AxisBench.hpp"
  #include <axis/AxisException.hpp>
  //#include <exception>
  #include <ctype.h>
  #include <iostream>
  #include <stdlib.h>
  #include <axis/Axis.hpp>
  /* Defining platform specific constants  */
  #include <time.h>
  
  #ifdef WIN32
          #include <windows.h>
  		#include "sys/timeb.h"
          #define RETTYPE DWORD WINAPI
          #define ARGTYPE LPVOID
    // Bug in MS Visual C++ 6.0. Fixed in Visual C++ .Net version.
    // Cannot print an __int64 number with cout without this overloading
   std::ostream& operator<<(std::ostream& os, __int64 i )
    {
      char buf[20];
      sprintf(buf,"%I64d", i );
      os << buf;
      return os;
    }
  
  #else
          #include <pthread.h>
          #include <unistd.h>
          #include "sys/time.h"
          #define RETTYPE void*
          #define ARGTYPE void*
  #endif
  
  
  //#define MACRO_NUM_THREADS 10
  //int NUM_THREADS = MACRO_NUM_THREADS;
  #define NUM_THREADS 5
  
  
  /* In windows the entry point function return type is DWORD WINAPI
     In linux it is void *                                          */
  RETTYPE ThreadFunc(ARGTYPE Param)
  {
          /*Type casting the url to char * */
          char *p=(char *)Param;
          char endpoint[256];
          const char* url="http://puppet.in.ibm.com:9060/Calculator/services/Calculator";
          AxisBench *ws;
  		BenchDataType *input = NULL;
  		BenchDataType *output = NULL;
  		xsd__unsignedByte* buffer = NULL;
          if(p!=NULL)
               url=p;
          int iResult;
          try
          {
                  sprintf(endpoint, "%s", url);
                  ws = new AxisBench(endpoint, APTHTTP1_1);
                  int request = 1;
        
  				input = new BenchDataType();
  				input->count = 100;
  			      
  			//    input->infos.m_Array = new BenchBasicDataType[input->count];
  				BenchBasicDataType **	ppBBDT = (BenchBasicDataType **) new BenchBasicDataType *[input->count];
  
  			#ifdef WIN32
  				__int64					ll = 10000;
  			#else
  				long long				ll = 10000;
  			#endif
  
  				input->infos.m_Array = ppBBDT;
  
  				input->infos.m_Size = input->count;
  			      
  				time_t tim;
  				tim = 1100246323;
  				struct tm *temp = gmtime(&tim);
  				struct tm lt;
  				memcpy(&lt, temp, sizeof(struct tm));
  
  			      
  				buffer = (xsd__unsignedByte*)calloc (1, input->count + 2);
  				strcpy ( (char *)buffer, "A");
  
  				for ( int i = 0; i < input->count ; i++ ) {
  					BenchBasicDataType *type = new BenchBasicDataType();
  					type->StringType = "StringType";
  					type->IntegerType = 10*(i+1);
  					type->DoubleType = 11.111 * (i+1);
  					type->BooleanType = true_;
  					type->DateTimeType = lt ;
  					type->TimeType = lt ;
  					type->DateType = lt ;
  					type->IntType = (i+1);
  					type->ByteType = '1';
  					type->DecimalType = 10*(i+1);
  					type->FloatType = (float)((float)(11*(i+1))/(float)2.0);
  					type->LongType = ll;
  					type->QNameType = "toto";
  					type->ShortType = (i+1);
  					type->Base64BinaryType.__size=i;
  					type->Base64BinaryType.__ptr=buffer;
  					type->HexBinary.__size=i;
  					type->HexBinary.__ptr=buffer;
  
  					if( i == 90)
  					{
  						*ppBBDT = type;
  			//			*ppBBDT = NULL;
  					}
  					else
  					{
  						*ppBBDT = type;
  					}
  
  					ppBBDT++;
  
  					if( ll == 0)
  					{
  						ll = 1;
  					}
  					else
  					{
  						ll += 10000;
  					}
  
  					strcat ( (char *)buffer, "A");
  				}
  
  				int t1,t2;
  			#ifndef WIN32  
  				struct timeval mstart;
  				struct timeval mstop;
  				gettimeofday( &mstart, NULL );
  			#else
  				struct timeb mstart;
  				struct timeb mstop;
  				ftime(&mstart);
  			#endif
  
  				for ( int ii = 0; ii < request ; ii++ ) {
  					if (output) { // Samisa: memory management BP
  						for (int i = 0; i < output->infos.m_Size; i++)
  							delete (BenchBasicDataType*)(output->infos.m_Array[i]);
  						delete output;
  						output = NULL;
  					}
  				output = ws->doBenchRequest(input);
  				}
  
  				free(buffer);
  
  			#ifndef WIN32
  				gettimeofday( &mstop, NULL );
  				t1 = mstart.tv_sec*1000 + mstart.tv_usec/1000;
  				t2 = mstop.tv_sec*1000 + mstop.tv_usec/1000;
  			#else
  				ftime(&mstop);
  				t1 = mstart.time*1000 + mstart.millitm;
  				t2 = mstop.time*1000 + mstop.millitm;
  			#endif
  
  				int total = t2-t1;
  			      
  				if ( ws->getStatus() == AXIS_FAIL )
  					cout << "Failed" << endl;
  				else 
  				{
     				char dateTime[50];
  				int i = 0;
  			    
  					if( output->infos.m_Array[i] != (BenchBasicDataType *) 0xcdcdcdcd)
  					{
  						cout << " StringType " << output->infos.m_Array[i]->StringType << endl;
  					}	
  				 
  					// returnValue=0;
  				}
    }catch(AxisException& e)
          {
              cout << "Exception : " << e.what() << endl;
          }
          catch(exception& e)
          {
              cout << "Unknown exception has occured" << endl;
          }
          catch(...)
          {
              cout << "Unknown exception has occured" << endl;
          }
    try
    {
  	  delete ws; 
  	  for (int i = 0; i < input->infos.m_Size; i++)
  	      delete (BenchBasicDataType*)(input->infos.m_Array[i]);
  	  delete input;
  	  if (output)
  	  {
  	    for (int i = 0; i < output->infos.m_Size; i++)
  	      delete (BenchBasicDataType*)(output->infos.m_Array[i]);
  	    delete output;
  	  }
    }
    catch(exception& exception)
    {
    	cout << "Exception on clean up: " << exception.what()<<endl;
    }
    catch(...)
    {
    	cout << "Unknown exception on clean up: " << endl;
    }
                  #ifndef WIN32
                          pthread_exit(0);
                  #endif
          return 0;
  }
  
  
  
  
  int main(int argc, char *argv[])
  {
      Axis::initialize(false);
  	try{
  		 int i;
  		 #ifdef WIN32
  			/*Windows specific code comes here */
  			HANDLE hThread[NUM_THREADS];
  			for(i=0;i<NUM_THREADS;i++){
  					DWORD dwThreadId;
  					//LPVOID dwThrdParam = LPVOID(argv[1]);
  					hThread[i] = CreateThread(
  											NULL,                        // no security attributes
  											0,                           // use default stack size
  											ThreadFunc,                  // thread function
  											LPVOID(argv[1]),             // argument to thread function
  											0,   
  										&dwThreadId);              // returns the thread identifier
  
  			if (hThread[i] == NULL)
  			{
  			cout<<"Thread creation Failed";
  			}
  			}
  			/* Waiting for threads to terminate */
  			WaitForMultipleObjects(NUM_THREADS,hThread,true, INFINITE);
  			for(i=0;i<NUM_THREADS;i++)
  					CloseHandle( hThread[i] );
  
  		#else	
  			pthread_t thread[NUM_THREADS];
  			pthread_attr_t attr;
  			int rc, t, status = 0;
  		//   Initialize and set thread detached attribute
  			pthread_attr_init(&attr);
  			pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
  			for (t = 0; t < NUM_THREADS; t++)
  			{
  			/*Creating threads */
  				rc = pthread_create(&thread[t], &attr, ThreadFunc,(void *)argv[1]);
  				if (rc)
  				{
  					cout<<"Thread Creation Failed";
  				}
  			}
  		//Free attribute and wait for the other threads
  		pthread_attr_destroy(&attr);
  		/* Wait for the threads to terminate  */
  		for(t=0;t<NUM_THREADS;t++){
  			rc = pthread_join(thread[t], (void **)&status);
  				if (rc)
  				{
  					cout<<"ERROR from pthread_join()"<<endl;
  				}
  		}
  	#endif
    }catch(exception &e){
             cout<< e.what();
    }
    cout<<endl <<"----------------------------------TEST COMPLETE--------------------------------"<<endl;
  }
  
  
  
  
  1.1                  ws-axis/c/tests/auto_build/testcases/client/cpp/SimpleTypeInnerUnboundedInOutput_TTestClient.cpp
  
  Index: SimpleTypeInnerUnboundedInOutput_TTestClient.cpp
  ===================================================================
  
  /* This program will create 10 Threads and each thread will invoke SimpleTypeInnerUnboundedInOutput Service 
     @Author James
  */
  
  #include "SimpleTypeInnerUnboundedInOutputWS.hpp"
  #include <axis/AxisException.hpp>
  //#include <exception>
  #include <ctype.h>
  #include <iostream>
  #include <stdlib.h>
  #include <axis/Axis.hpp>
  /* Defining platform specific constants  */
  #ifdef WIN32
          #include <windows.h>
          #define RETTYPE DWORD WINAPI
          #define ARGTYPE LPVOID
  #else
          #include <pthread.h>
          #include <unistd.h>
          #define RETTYPE void*
          #define ARGTYPE void*
  #endif
  
  
  //#define MACRO_NUM_THREADS 10
  //int NUM_THREADS = MACRO_NUM_THREADS;
  #define NUM_THREADS 10
  
  
  /* In windows the entry point function return type is DWORD WINAPI
     In linux it is void *                                          */
  RETTYPE ThreadFunc(ARGTYPE Param)
  {
          /*Type casting the url to char * */
          char *p=(char *)Param;
          char endpoint[256];
          const char* url="http://localhost:9080/SimpleTypeInnerUnboundedInOutput/services/sampleWS";
          if(p!=NULL)
               url=p;
            SimpleTypeInnerUnboundedInOutputWS *ws;
  
          try
          {
                  sprintf(endpoint, "%s", url);
                  ws=new  SimpleTypeInnerUnboundedInOutputWS(endpoint, APTHTTP1_1);
                  Type1* result;
  				int i;
  				int size = 10;
  
  				result = ws->getInput(size);
  
  				if ( result == NULL )
  					cout << "NULL" << endl;
  				else {
  					i=0;
  					char **pTemp = result->ident.m_Array;				
  					cout << "Result [" << i << "] : " << pTemp[i] << endl;
  				}	
  				delete ws;
          }
          catch(AxisException& e)
          {
              cout << "Exception : " << e.what() << endl;
          }
          catch(exception& e)
          {
              cout << "Unknown exception has occured" << endl;
          }
          catch(...)
          {
              cout << "Unknown exception has occured" << endl;
          }
                  #ifndef WIN32
                          pthread_exit(0);
                  #endif
          return 0;
  }
  
  
  
  
  int main(int argc, char *argv[])
  {
      Axis::initialize(false);
  	try{
  		 int i;
  		 #ifdef WIN32
  			/*Windows specific code comes here */
  			HANDLE hThread[NUM_THREADS];
  			for(i=0;i<NUM_THREADS;i++){
  					DWORD dwThreadId;
  					//LPVOID dwThrdParam = LPVOID(argv[1]);
  					hThread[i] = CreateThread(
  											NULL,                        // no security attributes
  											0,                           // use default stack size
  											ThreadFunc,                  // thread function
  											LPVOID(argv[1]),             // argument to thread function
  											0,   
  										&dwThreadId);              // returns the thread identifier
  
  			if (hThread[i] == NULL)
  			{
  			cout<<"Thread creation Failed";
  			}
  			}
  			/* Waiting for threads to terminate */
  			WaitForMultipleObjects(NUM_THREADS,hThread,true, INFINITE);
  			for(i=0;i<NUM_THREADS;i++)
  					CloseHandle( hThread[i] );
  
  		#else	
  			pthread_t thread[NUM_THREADS];
  			pthread_attr_t attr;
  			int rc, t, status = 0;
  		//   Initialize and set thread detached attribute
  			pthread_attr_init(&attr);
  			pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
  			for (t = 0; t < NUM_THREADS; t++)
  			{
  			/*Creating threads */
  				rc = pthread_create(&thread[t], &attr, ThreadFunc,(void *)argv[1]);
  				if (rc)
  				{
  					cout<<"Thread Creation Failed";
  				}
  			}
  		//Free attribute and wait for the other threads
  		pthread_attr_destroy(&attr);
  		/* Wait for the threads to terminate  */
  		for(t=0;t<NUM_THREADS;t++){
  			rc = pthread_join(thread[t], (void **)&status);
  				if (rc)
  				{
  					cout<<"ERROR from pthread_join()"<<endl;
  				}
  		}
  	#endif
    }catch(exception &e){
             cout<< e.what();
    }
    cout<<endl <<"----------------------------------TEST COMPLETE--------------------------------"<<endl;
  }