diff options
Diffstat (limited to 'TAO/tests')
23 files changed, 1500 insertions, 21 deletions
diff --git a/TAO/tests/DII_Collocation_Tests/DII_Collocation_Tests.mpc b/TAO/tests/DII_Collocation_Tests/DII_Collocation_Tests.mpc deleted file mode 100644 index bd3b9580390..00000000000 --- a/TAO/tests/DII_Collocation_Tests/DII_Collocation_Tests.mpc +++ /dev/null @@ -1,6 +0,0 @@ -// -*- MPC -*- -// $Id$ - -project(DII_Collocation_Tests): taoserver, dynamicinterface, minimum_corba{ - exename = Collocated_Test -} diff --git a/TAO/tests/DII_Collocation_Tests/Client_Task.cpp b/TAO/tests/DII_Collocation_Tests/oneway/Client_Task.cpp index f7c3f321248..f7c3f321248 100644 --- a/TAO/tests/DII_Collocation_Tests/Client_Task.cpp +++ b/TAO/tests/DII_Collocation_Tests/oneway/Client_Task.cpp diff --git a/TAO/tests/DII_Collocation_Tests/Client_Task.h b/TAO/tests/DII_Collocation_Tests/oneway/Client_Task.h index 2659536d7ad..2659536d7ad 100644 --- a/TAO/tests/DII_Collocation_Tests/Client_Task.h +++ b/TAO/tests/DII_Collocation_Tests/oneway/Client_Task.h diff --git a/TAO/tests/DII_Collocation_Tests/Collocated_Test.cpp b/TAO/tests/DII_Collocation_Tests/oneway/Collocated_Test.cpp index a67aa4f416e..a67aa4f416e 100644 --- a/TAO/tests/DII_Collocation_Tests/Collocated_Test.cpp +++ b/TAO/tests/DII_Collocation_Tests/oneway/Collocated_Test.cpp diff --git a/TAO/tests/DII_Collocation_Tests/oneway/DII_Collocation_Tests.mpc b/TAO/tests/DII_Collocation_Tests/oneway/DII_Collocation_Tests.mpc new file mode 100644 index 00000000000..afa9884eed8 --- /dev/null +++ b/TAO/tests/DII_Collocation_Tests/oneway/DII_Collocation_Tests.mpc @@ -0,0 +1,6 @@ +// -*- MPC -*- +// $Id$ + +project(*oneway) : taoserver, dynamicinterface, minimum_corba{ + exename = Collocated_Test +} diff --git a/TAO/tests/DII_Collocation_Tests/Hello.cpp b/TAO/tests/DII_Collocation_Tests/oneway/Hello.cpp index dc2030bf61e..dc2030bf61e 100644 --- a/TAO/tests/DII_Collocation_Tests/Hello.cpp +++ b/TAO/tests/DII_Collocation_Tests/oneway/Hello.cpp diff --git a/TAO/tests/DII_Collocation_Tests/Hello.h b/TAO/tests/DII_Collocation_Tests/oneway/Hello.h index 7125b75f789..8dde8446d54 100644 --- a/TAO/tests/DII_Collocation_Tests/Hello.h +++ b/TAO/tests/DII_Collocation_Tests/oneway/Hello.h @@ -8,16 +8,10 @@ #include "TestS.h" -#if defined (_MSC_VER) -# if (_MSC_VER >= 1200) -# pragma warning(push) -# endif /* _MSC_VER >= 1200 */ -# pragma warning (disable:4250) -#endif /* _MSC_VER */ - #include "ace/OS.h" -class Test_Simple_Test_i : public virtual POA_Test::Simple_Test, public virtual PortableServer::RefCountServantBase +class Test_Simple_Test_i + : public virtual POA_Test::Simple_Test { public: //Constructor @@ -39,7 +33,6 @@ public: /// Implement the Test::Hello interface class Hello : public virtual POA_Test::Hello - , public virtual PortableServer::RefCountServantBase { public: /// Constructor @@ -209,9 +202,6 @@ private: CORBA::ULong error_count_; }; -#if defined(_MSC_VER) && (_MSC_VER >= 1200) -# pragma warning(pop) -#endif /* _MSC_VER */ #include /**/ "ace/post.h" #endif /* HELLO_H */ diff --git a/TAO/tests/DII_Collocation_Tests/README b/TAO/tests/DII_Collocation_Tests/oneway/README index 26641a1d9f2..cc947507808 100644 --- a/TAO/tests/DII_Collocation_Tests/README +++ b/TAO/tests/DII_Collocation_Tests/oneway/README @@ -1,8 +1,9 @@ # $Id$ Description: -This test is used to test the bug fix on collocated dii send_oneway() -invocation crash on get_in_arg() when the request has multiple "IN" parameters. +This test is used to test the bug fix on collocated dii oneway request +invocation via send_oneway() crash on get_in_arg() when the request has multiple +"IN" parameters. The test.idl defines oneway operations with all sorts SArgument to test the conversion of the DII parameters in NVList to the list of arguments. diff --git a/TAO/tests/DII_Collocation_Tests/Server_Task.cpp b/TAO/tests/DII_Collocation_Tests/oneway/Server_Task.cpp index 15754f7aaf3..15754f7aaf3 100644 --- a/TAO/tests/DII_Collocation_Tests/Server_Task.cpp +++ b/TAO/tests/DII_Collocation_Tests/oneway/Server_Task.cpp diff --git a/TAO/tests/DII_Collocation_Tests/Server_Task.h b/TAO/tests/DII_Collocation_Tests/oneway/Server_Task.h index cd8b0582e6f..cd8b0582e6f 100644 --- a/TAO/tests/DII_Collocation_Tests/Server_Task.h +++ b/TAO/tests/DII_Collocation_Tests/oneway/Server_Task.h diff --git a/TAO/tests/DII_Collocation_Tests/Test.idl b/TAO/tests/DII_Collocation_Tests/oneway/Test.idl index 3bd69e1642a..3bd69e1642a 100644 --- a/TAO/tests/DII_Collocation_Tests/Test.idl +++ b/TAO/tests/DII_Collocation_Tests/oneway/Test.idl diff --git a/TAO/tests/DII_Collocation_Tests/run_test.pl b/TAO/tests/DII_Collocation_Tests/oneway/run_test.pl index 73766e57cc5..592179ac316 100755 --- a/TAO/tests/DII_Collocation_Tests/run_test.pl +++ b/TAO/tests/DII_Collocation_Tests/oneway/run_test.pl @@ -5,7 +5,7 @@ eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' # $Id$ # -*- perl -*- -use lib '../../../bin'; +use lib '../../../../bin'; use PerlACE::Run_Test; $iorfile = PerlACE::LocalFile ("test.ior"); diff --git a/TAO/tests/DII_Collocation_Tests/twoway/Client_Task.cpp b/TAO/tests/DII_Collocation_Tests/twoway/Client_Task.cpp new file mode 100644 index 00000000000..b2059192997 --- /dev/null +++ b/TAO/tests/DII_Collocation_Tests/twoway/Client_Task.cpp @@ -0,0 +1,285 @@ +// +// $Id$ +// + +#include "tao/DynamicInterface/Request.h" /* This must come first for + G++ 3.4 or better */ +#include "Client_Task.h" +#include "TestC.h" +#include "tao/Object.h" + +ACE_RCSID(DII_Collocation_Tests, Client_Task, "$Id$") + +char TEST_STR[] = "This is a DII collocation test."; +CORBA::Long TEST_BASIC_VALUE = 12345; +CORBA::Char TEST_SPECIAL_VALUE = 'x'; +CORBA::Short TEST_HOUR = 12; +CORBA::Short TEST_MINUTE = 59; +CORBA::Short TEST_SECOND = 59; + +Client_Task::Client_Task (const char *ior, + const char *simple_test_ior, + CORBA::ORB_ptr corb, + ACE_Thread_Manager *thr_mgr) + : ACE_Task_Base (thr_mgr) + , input_ (ior) + , simple_test_input_ (simple_test_ior) + , corb_ (CORBA::ORB::_duplicate (corb)) + , error_count_ (0) +{ +} + +int +Client_Task::svc (void) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj = + this->corb_->string_to_object (input_ ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (CORBA::is_nil (obj.in ())) + { + ACE_ERROR_RETURN ((LM_DEBUG, + "Nil Test::Hello reference <%s>\n", + input_), + 1); + } + + CORBA::Object_var simple_test_obj = + this->corb_->string_to_object (simple_test_input_ ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (CORBA::is_nil (simple_test_obj.in ())) + { + ACE_ERROR_RETURN ((LM_DEBUG, + "Nil Test::Simple_Test reference <%s>\n", + simple_test_input_), + 1); + } + + Test::Simple_Test_var simple_test + = Test::Simple_Test::_narrow (simple_test_obj.in () ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::Request_var req (obj->_request ("test_basic_arg" ACE_ENV_ARG_PARAMETER)); + ACE_TRY_CHECK; + req->add_in_arg ("basic") <<= TEST_BASIC_VALUE; + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + + req = obj->_request ("test_unbounded_string_arg" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + req->add_in_arg ("ub_string") <<= TEST_STR; + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + + req = obj->_request ("test_bounded_string_arg" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + ACE_CString bs (TEST_STR); + bs = bs.substr (0, ::Test::BOUNDED_STRING_SIZE); + + req->add_in_arg ("bd_string") + <<= CORBA::Any::from_string (bs.c_str (), ::Test::BOUNDED_STRING_SIZE); + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + + req = obj->_request ("test_fixed_array_arg" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + ::Test::Fixed_Array fixed_array; + + for (CORBA::ULong m = 0 ; m < ::Test::FIX_ARRAY_SIZE; m ++) + { + fixed_array[m] = m + 999; + } + + req->add_in_arg ("fixed_array") <<= ::Test::Fixed_Array_forany (fixed_array); + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + + req = obj->_request ("test_var_array_arg" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + ::Test::Var_Array var_array; + + for (CORBA::ULong i = 0; i < ::Test::VAR_ARRAY_SIZE; ++i) + { + var_array[i] = CORBA::string_dup(TEST_STR); + } + + req->add_in_arg ("var_array") <<= var_array; + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + + req = obj->_request ("test_bounded_var_size_arg" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + ACE_CString bvs (TEST_STR); + bvs = bvs.substr (0, ::Test::BOUNDED_VAR_SIZE); + + ::Test::Bounded_Var_Size_Arg* bd_var_size + = new ::Test::Bounded_Var_Size_Arg(); + + bd_var_size->replace (::Test::BOUNDED_VAR_SIZE, + const_cast <CORBA::Char*> (bvs.c_str ())); + + req->add_in_arg ("bd_var_size") <<= bd_var_size; + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + + req = obj->_request ("test_unbounded_var_size_arg" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + ::Test::Unbounded_Var_Size_Arg* ub_var_size + = new ::Test::Unbounded_Var_Size_Arg(); + ub_var_size->replace (ub_var_size->maximum (), + ACE_OS::strlen (TEST_STR), + TEST_STR); + + req->add_in_arg ("ub_var_size") <<= ub_var_size; + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + + req = obj->_request ("test_fixed_size_arg" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + ::Test::TimeOfDay t; + t.hour = TEST_HOUR; + t.minute = TEST_MINUTE; + t.second = TEST_SECOND; + + req->add_in_arg ("fixed_size") <<= t; + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + + req = obj->_request ("test_special_basic_arg" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + req->add_in_arg ("special") <<= CORBA::Any::from_char (TEST_SPECIAL_VALUE); + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + + req = obj->_request ("test_object_arg" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + req->add_in_arg ("object") <<= simple_test_obj.in (); + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + + req = obj->_request ("test_objref_arg" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + req->add_in_arg ("objref") <<= simple_test.in (); + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + + req = obj->_request ("test_args_1" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + req->add_in_arg ("arg1") <<= simple_test_obj.in (); + req->add_in_arg ("arg2") <<= CORBA::Any::from_char (TEST_SPECIAL_VALUE); + req->add_in_arg ("arg3") <<= simple_test.in (); + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + + req = obj->_request ("test_args_2" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + req->add_in_arg ("arg1") <<= TEST_STR; + req->add_in_arg ("arg2") <<= ::Test::Fixed_Array_forany (fixed_array); + req->add_in_arg ("arg3") <<= t; + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + + req = obj->_request ("test_args_3" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + bd_var_size + = new ::Test::Bounded_Var_Size_Arg(); + bd_var_size->replace (::Test::BOUNDED_VAR_SIZE, + const_cast <CORBA::Char*> (bvs.c_str ())); + + ub_var_size + = new ::Test::Unbounded_Var_Size_Arg(); + ub_var_size->replace (ub_var_size->maximum (), + ACE_OS::strlen (TEST_STR), + TEST_STR); + + for (CORBA::ULong j = 0; j < ::Test::VAR_ARRAY_SIZE; ++j) + { + var_array[j] = CORBA::string_dup(TEST_STR); + } + + req->add_in_arg ("arg1") + <<= CORBA::Any::from_string (bs.c_str (), ::Test::BOUNDED_STRING_SIZE); + + req->add_in_arg ("arg2") <<= bd_var_size; + req->add_in_arg ("arg3") <<= ub_var_size; + req->add_in_arg ("arg4") <<= var_array; + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + + req = obj->_request ("shutdown" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + req->send_oneway (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + + } + ACE_CATCHANY + { + error_count_ ++; + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Exception caught:"); + return 1; + } + ACE_CATCHALL + { + error_count_ ++; + ACE_ERROR ((LM_ERROR, "(%P|%t)Client_Task::svc - caught unknown exception \n")); + return 1; + } + ACE_ENDTRY; + + return 0; + +} + +CORBA::ULong +Client_Task::error_count () const +{ + return error_count_; +} + diff --git a/TAO/tests/DII_Collocation_Tests/twoway/Client_Task.h b/TAO/tests/DII_Collocation_Tests/twoway/Client_Task.h new file mode 100644 index 00000000000..2659536d7ad --- /dev/null +++ b/TAO/tests/DII_Collocation_Tests/twoway/Client_Task.h @@ -0,0 +1,41 @@ +// +// $Id$ +// + +#ifndef COLLOCATED_TEST_CLIENT_TASK_H +#define COLLOCATED_TEST_CLIENT_TASK_H +#include /**/ "ace/pre.h" +#include "ace/Task.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ +#include "tao/ORB.h" + + +/// Implement a Task to run the client as a thread +class Client_Task : public ACE_Task_Base +{ +public: + + /// Constructor + Client_Task (const char *input, + const char *simple_test_ior, + CORBA::ORB_ptr corb, + ACE_Thread_Manager *thr_mgr); + + /// Thread entry point + int svc (void); + + CORBA::ULong error_count () const; + +private: + const char *input_; + const char *simple_test_input_; + + CORBA::ORB_var corb_; + CORBA::ULong error_count_; +}; + +#include /**/ "ace/post.h" +#endif /* COLLOCATED_TEST_CLIENT_TASK_H */ diff --git a/TAO/tests/DII_Collocation_Tests/twoway/Collocated_Test.cpp b/TAO/tests/DII_Collocation_Tests/twoway/Collocated_Test.cpp new file mode 100644 index 00000000000..3e2bab6c3fc --- /dev/null +++ b/TAO/tests/DII_Collocation_Tests/twoway/Collocated_Test.cpp @@ -0,0 +1,140 @@ +//$Id$ + +// This include is needed for static builds to initialize DII_Arguments_Converter +// service object. +//#include "tao/DynamicInterface/DII_Arguments_Converter_Impl.h" + +#include "Server_Task.h" +#include "Client_Task.h" +#include "ace/Get_Opt.h" +#include "ace/Argv_Type_Converter.h" +#include "ace/SString.h" +#include "ace/Manual_Event.h" + +const char *output = "server.ior"; +const char *input = "file://server.ior"; +const char *simple_test_output = "simple_test.ior"; +const char *simple_test_input = "file://simple_test.ior"; +// static int named_orbs = 0; +ACE_CString server_orb; +ACE_CString client_orb; + +CORBA::Boolean debug = 0; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "k:o:nd"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'o': + output = get_opts.opt_arg (); + break; + case 'k': + input = get_opts.opt_arg (); + break; + case 'n': + // named_orbs = 1; + server_orb.set ("server_orb"); + client_orb.set ("client_orb"); + break; + case 'd': + debug = 1; + break; + case '?': + default: + // This is a hack but that is okay! + return 0; + } + // Indicates sucessful parsing of the command line + return 0; +} + +int +main (int argc, char *argv[]) +{ + if (parse_args (argc, + argv) == -1) + return -1; + + ACE_DECLARE_NEW_CORBA_ENV; + ACE_TRY + { + ACE_Argv_Type_Converter satc (argc, argv); + CORBA::ORB_var sorb = + CORBA::ORB_init (satc.get_argc (), + satc.get_TCHAR_argv (), + server_orb.c_str () + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + ACE_Manual_Event me; + Server_Task server_task (output, + simple_test_output, + sorb.in (), + me, + ACE_Thread_Manager::instance ()); + + if (server_task.activate (THR_NEW_LWP | THR_JOINABLE, + 1, + 1) == -1) + { + ACE_ERROR ((LM_ERROR, "Error activating server task\n")); + } + + // Wait for the server thread to do some processing + me.wait (); + + ACE_Argv_Type_Converter catc (argc, argv); + CORBA::ORB_var corb = + CORBA::ORB_init (catc.get_argc (), + catc.get_TCHAR_argv (), + client_orb.c_str () + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + Client_Task client_task (input, + simple_test_input, + corb.in (), + ACE_Thread_Manager::instance ()); + + if (client_task.activate (THR_NEW_LWP | THR_JOINABLE, + 1, + 1) == -1) + { + ACE_ERROR ((LM_ERROR, "Error activating client task\n")); + } + + // Wait for the client and server to finish + ACE_Thread_Manager::instance ()->wait (); + + // Now that all threads have completed we can destroy the ORB + sorb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + if (server_orb != client_orb) + { + corb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + } + + CORBA::ULong errors = client_task.error_count () + server_task.error_count (); + if (errors == 0) + { + ACE_DEBUG((LM_DEBUG, "(%P|%t) test passed\n")); + } + else + { + ACE_DEBUG((LM_DEBUG, "(%P|%t) test failed - error_count=%u\n", errors)); + return 1; + } + } + ACE_CATCHANY + { + // Ignore exceptions.. + } + ACE_ENDTRY; + return 0; +} diff --git a/TAO/tests/DII_Collocation_Tests/twoway/DII_Collocation_Tests.mpc b/TAO/tests/DII_Collocation_Tests/twoway/DII_Collocation_Tests.mpc new file mode 100644 index 00000000000..c77ecfa435b --- /dev/null +++ b/TAO/tests/DII_Collocation_Tests/twoway/DII_Collocation_Tests.mpc @@ -0,0 +1,6 @@ +// -*- MPC -*- +// $Id$ + +project(*twoway) : taoserver, dynamicinterface, minimum_corba{ + exename = Collocated_Test +} diff --git a/TAO/tests/DII_Collocation_Tests/twoway/Hello.cpp b/TAO/tests/DII_Collocation_Tests/twoway/Hello.cpp new file mode 100644 index 00000000000..dc2030bf61e --- /dev/null +++ b/TAO/tests/DII_Collocation_Tests/twoway/Hello.cpp @@ -0,0 +1,397 @@ +// +// $Id$ +// +#include "Hello.h" +#include "tao/ORB_Core.h" +#include "tao/ORB_Table.h" + +ACE_RCSID(DII_Collocation_Tests, Hello, "$Id$") + +extern CORBA::Boolean debug; +extern char TEST_STR[]; +extern CORBA::Long TEST_BASIC_VALUE; +extern CORBA::Char TEST_SPECIAL_VALUE; +extern CORBA::Short TEST_HOUR; +extern CORBA::Short TEST_MINUTE; +extern CORBA::Short TEST_SECOND; + +#define ERROR_COUNT(message) \ +{ error_count_ ++; \ + ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t)%s - failed error_count = %u\n"), \ + message, error_count_)); \ +} + +// Implementation skeleton constructor +Test_Simple_Test_i::Test_Simple_Test_i (void) +{ +} + +// Implementation skeleton destructor +Test_Simple_Test_i::~Test_Simple_Test_i (void) +{ +} + +void Test_Simple_Test_i::test_method ( + ::CORBA::ULong & error_count + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + error_count --; +} + +Hello::Hello (CORBA::ORB_ptr orb, + ACE_thread_t thrid) + : orb_ (CORBA::ORB::_duplicate (orb)) + , thr_id_ (thrid) + , error_count_ (0) +{ +} + +void +Hello::test_basic_arg ( + ::CORBA::Long basic + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + if (basic != TEST_BASIC_VALUE) + ERROR_COUNT ("Hello::test_basic_arg") +} + +void +Hello::test_unbounded_string_arg(const char* message + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC((CORBA::SystemException)) +{ + if (debug) + ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t)Hello::test_unbounded_string_arg ") + ACE_TEXT("got unbounded string: %s\n"), + message)); + if (ACE_OS::strncmp (message, TEST_STR, strlen (TEST_STR) != 0)) + { + ERROR_COUNT ("Hello::test_unbounded_string_arg") + } +} + + +void +Hello::test_bounded_string_arg(const char* message + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC((CORBA::SystemException)) +{ + if (debug) + ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t)Hello::test_bounded_string_arg ") + ACE_TEXT("got bounded string: %s\n"), + message)); + if (ACE_OS::strncmp (message, TEST_STR, ::Test::BOUNDED_STRING_SIZE) != 0) + { + ERROR_COUNT ("Hello::test_bounded_string_arg") + } +} + + +void +Hello::test_fixed_array_arg(const ::Test::Fixed_Array message + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC((CORBA::SystemException)) +{ + for (unsigned i = 0; i < ::Test::FIX_ARRAY_SIZE; i++) + { + if (debug) + ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t)Hello::test_fixed_array_arg ") + ACE_TEXT("got fixed array: %d\n"), + message[i])); + if (message[i] != static_cast<CORBA::Long> (i + 999)) + ERROR_COUNT ("Hello::test_fixed_array_arg") + } +} + + +void +Hello::test_bounded_var_size_arg(const ::Test::Bounded_Var_Size_Arg& message + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC((CORBA::SystemException)) +{ + if (debug) + ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t)Hello::test_bounded_var_size_arg ") + ACE_TEXT("got bounded var size arg\n"))); + if (ACE_OS::strncmp (message.get_buffer (), TEST_STR, ::Test::BOUNDED_VAR_SIZE) != 0) + ERROR_COUNT ("Hello::test_bounded_var_size_arg") +} + + +void +Hello::test_unbounded_var_size_arg(const ::Test::Unbounded_Var_Size_Arg& message + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC((CORBA::SystemException)) +{ + if (debug) + ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t)Hello::test_unbounded_var_size_arg ") + ACE_TEXT("got unbounded var size arg.\n"))); + if (ACE_OS::strncmp (message.get_buffer (), TEST_STR, strlen (TEST_STR)) != 0) + ERROR_COUNT ("Hello::test_unbounded_var_size_arg") +} + + +void +Hello::test_fixed_size_arg(const ::Test::TimeOfDay& t + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + if (debug) + ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t)Hello::test_fixed_size_arg ") + ACE_TEXT("got timeofday: %d:%d:%d\n"), + t.hour, t.minute, t.second)); + + if (t.hour != TEST_HOUR + || t.minute != TEST_MINUTE + || t.second != TEST_SECOND) + ERROR_COUNT ("Hello::test_fixed_size_arg") +} + + +void +Hello::test_var_array_arg(const Test::Var_Array messages + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC((CORBA::SystemException)) +{ + for (CORBA::ULong i = 0; i != ::Test::VAR_ARRAY_SIZE; i ++) + { + if (debug) + ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t)Hello::test_var_array_arg ") + ACE_TEXT("messages[%d] = %s \n"), i, messages[i].in ())); + if (ACE_OS::strncmp (messages[i].in (), TEST_STR, strlen (TEST_STR)) != 0) + ERROR_COUNT ("Hello::test_var_array_arg") + } +} + + +void +Hello::test_special_basic_arg(CORBA::Char value + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC((CORBA::SystemException)) +{ + if (debug) + ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t)Hello::test_special_basic_arg ") + ACE_TEXT(" got special basic arg: %c \n"), value)); + if (value != TEST_SPECIAL_VALUE) + ERROR_COUNT ("Hello::test_special_basic_arg") +} + + +void Hello::test_objref_arg ( + ::Test::Simple_Test_ptr test + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + if (debug) + ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t)Hello::test_objref_arg \n"))); + + if (CORBA::is_nil (test)) + ERROR_COUNT ("Hello::test_objref_arg") + else + { + // Increment the error_count before calling test_method() and decrement + // the error_count when the server handling the test_method() call. + CORBA::ULong error_count = 0; + error_count ++; + test->test_method (error_count ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + if (error_count != 0) + { + ERROR_COUNT ("Hello::test_objref_arg") + } + } +} + +void Hello::test_object_arg ( + ::CORBA::Object_ptr o + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + if (debug) + ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t)Hello::test_object_arg \n"))); + ::Test::Simple_Test_var simple_test = ::Test::Simple_Test::_narrow (o); + + CORBA::ULong error_count = 0; + error_count ++; + simple_test->test_method (error_count ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + if (error_count != 0) + { + ERROR_COUNT ("Hello::test_object_arg") + } +} + +void Hello::test_args_1 ( + ::CORBA::Object_ptr arg1, + ::CORBA::Char arg2, + ::Test::Simple_Test_ptr arg3 + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + if (debug) + ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t)Hello::test_args_1 \n"))); + ::Test::Simple_Test_var simple_test = ::Test::Simple_Test::_narrow (arg1); + + CORBA::ULong error_count = 0; + error_count ++; + simple_test->test_method (error_count ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + error_count ++; + arg3->test_method (error_count ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + if (error_count != 0) + { + ERROR_COUNT ("Hello::test_args_1") + } + + if (arg2 != TEST_SPECIAL_VALUE) + ERROR_COUNT ("Hello::test_args_1") +} + +void Hello::test_args_2 ( + const char * arg1, + const ::Test::Fixed_Array arg2, + const ::Test::TimeOfDay & arg3 + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + if (debug) + ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t)Hello::test_args_2 \n"))); + if (ACE_OS::strncmp (arg1, TEST_STR, strlen (TEST_STR)) != 0 ) + ERROR_COUNT ("Hello::test_args_2") + + for (unsigned i = 0; i < ::Test::FIX_ARRAY_SIZE; i++) + { + if (arg2[i] != static_cast<CORBA::Long> (i + 999)) + ERROR_COUNT ("Hello::test_args_2") + } + + if (arg3.hour != TEST_HOUR + || arg3.minute != TEST_MINUTE + || arg3.second != TEST_SECOND) + ERROR_COUNT ("Hello::test_args_2") +} + +void Hello::test_args_3 ( + const char * arg1, + const ::Test::Bounded_Var_Size_Arg & arg2, + const ::Test::Unbounded_Var_Size_Arg & arg3, + const ::Test::Var_Array arg4 + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + if (debug) + ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t)Hello::test_args_3 \n"))); + if (ACE_OS::strncmp (arg1, TEST_STR, strlen (arg1)) != 0) + ERROR_COUNT ("Hello::test_args_3") + if (ACE_OS::strncmp (arg2.get_buffer (), TEST_STR, ::Test::BOUNDED_VAR_SIZE) != 0) + ERROR_COUNT ("Hello::test_args_3") + if (ACE_OS::strncmp (arg3.get_buffer (), TEST_STR, strlen (TEST_STR)) != 0) + ERROR_COUNT ("Hello::test_args_3") + for (CORBA::ULong i = 0; i != ::Test::VAR_ARRAY_SIZE; i ++) + { + if (ACE_OS::strncmp (arg4[i].in (), TEST_STR, strlen (TEST_STR)) != 0) + ERROR_COUNT ("Hello::test_args_3") + } +} + +char * +Hello::get_string (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + if (debug) + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Upcall in process ..\n")); + + if (ACE_Thread::self () == this->thr_id_) + { + if (this->orb_->orb_core ()->optimize_collocation_objects () && + this->orb_->orb_core ()->use_global_collocation ()) + { + ACE_ERROR ((LM_ERROR, + "(%P|%t) ERROR: A remote call has been made " + " exiting ..\n")); + ACE_OS::abort (); + } + else if (this->orb_->orb_core ()->optimize_collocation_objects () && + this->orb_->orb_core ()->use_global_collocation () == 0) + { + TAO::ORB_Table * const orb_table = + TAO::ORB_Table::instance (); + + if (orb_table->find ("server_orb") == 0) + { + // We are running on a single ORB and this is an error. + ACE_ERROR ((LM_ERROR, + "(%P|%t) ERROR: A remote call has been made " + " with a single ORB " + " exiting ..\n")); + ACE_OS::abort (); + } + } + } + + return CORBA::string_dup ("Hello there!"); +} + +char * +Hello::test_unbounded_string ( + const char * s1, + char *& s2, + CORBA::String_out s3 + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + char *retstr = CORBA::string_dup (s1); + s3 = CORBA::string_dup (s1); + char *tmp = CORBA::string_alloc (2*ACE_OS::strlen (s2)); + ACE_OS::sprintf (tmp, "%s%s", s2, s2); + CORBA::string_free (s2); + s2 = tmp; + return retstr; +} + +void +Hello::shutdown (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Give the client thread time to return from the collocated + // call to this method before shutting down the ORB. We sleep + // to avoid BAD_INV_ORDER exceptions on fast dual processor machines. + ACE_OS::sleep (1); + this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER); +} + +CORBA::ULong Hello::error_count () const +{ + return error_count_; +} + + + diff --git a/TAO/tests/DII_Collocation_Tests/twoway/Hello.h b/TAO/tests/DII_Collocation_Tests/twoway/Hello.h new file mode 100644 index 00000000000..8dde8446d54 --- /dev/null +++ b/TAO/tests/DII_Collocation_Tests/twoway/Hello.h @@ -0,0 +1,207 @@ +// +// $Id$ +// + +#ifndef HELLO_H +#define HELLO_H +#include /**/ "ace/pre.h" + +#include "TestS.h" + +#include "ace/OS.h" + +class Test_Simple_Test_i + : public virtual POA_Test::Simple_Test +{ +public: + //Constructor + Test_Simple_Test_i (void); + + //Destructor + virtual ~Test_Simple_Test_i (void); + + virtual + void test_method ( + ::CORBA::ULong & error_count + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); +}; + +/// Implement the Test::Hello interface +class Hello + : public virtual POA_Test::Hello +{ +public: + /// Constructor + Hello (CORBA::ORB_ptr orb, + ACE_thread_t thr_id); + + // = The skeleton methods + virtual + void test_basic_arg ( + ::CORBA::Long basic + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual + void test_unbounded_string_arg ( + const char * message + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual + void test_bounded_string_arg ( + const char * message + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual + void test_fixed_array_arg ( + const ::Test::Fixed_Array message + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual + void test_var_array_arg ( + const ::Test::Var_Array messages + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual + void test_bounded_var_size_arg ( + const ::Test::Bounded_Var_Size_Arg & message + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual + void test_unbounded_var_size_arg ( + const ::Test::Unbounded_Var_Size_Arg & message + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual + void test_fixed_size_arg ( + const ::Test::TimeOfDay & t + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual + void test_special_basic_arg ( + ::CORBA::Char value + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual + void test_objref_arg ( + ::Test::Simple_Test_ptr test + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual + void test_object_arg ( + ::CORBA::Object_ptr o + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual + void test_args_1 ( + ::CORBA::Object_ptr arg1, + ::CORBA::Char arg2, + ::Test::Simple_Test_ptr arg3 + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual + void test_args_2 ( + const char * arg1, + const ::Test::Fixed_Array arg2, + const ::Test::TimeOfDay & arg3 + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual + void test_args_3 ( + const char * arg1, + const ::Test::Bounded_Var_Size_Arg & arg2, + const ::Test::Unbounded_Var_Size_Arg & arg3, + const ::Test::Var_Array arg4 + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual char * get_string (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual + char * test_unbounded_string ( + const char * s1, + char *& s2, + CORBA::String_out s3 + ACE_ENV_ARG_DECL + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + + CORBA::ULong error_count () const; + +private: + /// Use an ORB reference to conver strings to objects and shutdown + /// the application. + CORBA::ORB_var orb_; + + ACE_thread_t thr_id_; + + CORBA::ULong error_count_; +}; + + +#include /**/ "ace/post.h" +#endif /* HELLO_H */ diff --git a/TAO/tests/DII_Collocation_Tests/twoway/README b/TAO/tests/DII_Collocation_Tests/twoway/README new file mode 100644 index 00000000000..a61b5bf1da8 --- /dev/null +++ b/TAO/tests/DII_Collocation_Tests/twoway/README @@ -0,0 +1,55 @@ +# $Id$ + +Description: +This test is used to test the bug fix on collocated dii twoway request +invocation via invoke() crash on get_in_arg() when the request has multiple +"IN" parameters. + +The test.idl defines twoway operations with all sorts SArgument to test the +conversion of the DII parameters in NVList to the list of arguments. +It also defines the operations with multiple "IN" arguments to test the +bug fix. + + +This test is a modification of the Collocation_Tests. The big difference is +this test invokes the twoway operations using DII while the Collocation_Tests +invoke a simple twoway operations. + + +Usage: +===== + +The run_test.pl runs several test cases listed below. The test result will be printed +after the test completes. To debug the test failure, the operation "-d" can be passed +to have verbose log. + + +======== Running in Default Mode + +Collocated_Test -o test.ior -k file://test.ior + + +======== Running with per-orb + +Collocated_Test -o test.ior -k file://test.ior -ORBCollocation per-orb + + +======== Running with no collocation + +Collocated_Test -o test.ior -k file://test.ior -ORBCollocation no + + +======== Running in default mode and two ORBS + +Collocated_Test -o test.ior -k file://test.ior -n + + +======== Running in per-orb mode and two ORBS + +Collocated_Test -o test.ior -k file://test.ior -n -ORBCollocation per-orb + + +======== Running in no collocation mode and two ORBS + +Collocated_Test -o test.ior -k file://test.ior -n -ORBCollocation per-orb + diff --git a/TAO/tests/DII_Collocation_Tests/twoway/Server_Task.cpp b/TAO/tests/DII_Collocation_Tests/twoway/Server_Task.cpp new file mode 100644 index 00000000000..15754f7aaf3 --- /dev/null +++ b/TAO/tests/DII_Collocation_Tests/twoway/Server_Task.cpp @@ -0,0 +1,150 @@ +// +// $Id$ +// +#include "Server_Task.h" +#include "TestS.h" +#include "Hello.h" + +#include "ace/Manual_Event.h" + +ACE_RCSID(DII_Collocation_Tests, + Server_Task, + "$Id$") + + +Server_Task::Server_Task (const char *output, + const char *simple_test_output, + CORBA::ORB_ptr sorb, + ACE_Manual_Event &me, + ACE_Thread_Manager *thr_mgr) + : ACE_Task_Base (thr_mgr) + , output_ (output) + , simple_test_output_ (simple_test_output) + , me_ (me) + , sorb_ (CORBA::ORB::_duplicate (sorb)) + , error_count_ (0) +{ +} + +int +Server_Task::svc (void) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var poa_object = + this->sorb_->resolve_initial_references("RootPOA" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + PortableServer::POA_var root_poa = + PortableServer::POA::_narrow (poa_object.in () + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (CORBA::is_nil (root_poa.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Panic: nil RootPOA\n"), + 1); + + PortableServer::POAManager_var poa_manager = + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + Hello *hello_impl; + ACE_NEW_RETURN (hello_impl, + Hello (this->sorb_.in (), + ACE_Thread::self ()), + 1); + + PortableServer::ServantBase_var owner_transfer(hello_impl); + + Test::Hello_var hello = + hello_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::String_var ior = + this->sorb_->object_to_string (hello.in () + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + // Output the IOR to the <this->output_> + FILE *output_file= ACE_OS::fopen (this->output_, + "w"); + if (output_file == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing Hello IOR: %s", + this->output_), + 1); + + ACE_OS::fprintf (output_file, "%s", ior.in ()); + ACE_OS::fclose (output_file); + + Test_Simple_Test_i *simple_impl; + ACE_NEW_RETURN (simple_impl, + Test_Simple_Test_i (), + 1); + + PortableServer::ServantBase_var owner_transfer_simple(simple_impl); + + Test::Simple_Test_var simple_test = + simple_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::String_var simple_test_ior = + this->sorb_->object_to_string (simple_test.in () + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + // Output the IOR to the <this->output_> + FILE *simple_test_output_file= ACE_OS::fopen (this->simple_test_output_, + "w"); + if (simple_test_output_file == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing Simple_Test IOR: %s", + this->simple_test_output_), + 1); + + ACE_OS::fprintf (simple_test_output_file, "%s", simple_test_ior.in ()); + ACE_OS::fclose (simple_test_output_file); + + poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + // Signal the main thread before we call orb->run (); + this->me_.signal (); + + this->sorb_->run (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); + + ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - verifing results\n")); + + CORBA::ULong errors = hello_impl->error_count (); + + error_count_ += errors; + } + ACE_CATCHANY + { + error_count_ ++; + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Exception caught:"); + return 1; + } + ACE_CATCHALL + { + error_count_ ++; + ACE_ERROR ((LM_ERROR, "(%P|%t)Server_Task::svc - caught unknown exception \n")); + return 1; + } + ACE_ENDTRY; + + return 0; +} + +CORBA::ULong +Server_Task::error_count () const +{ + return error_count_; +} + diff --git a/TAO/tests/DII_Collocation_Tests/twoway/Server_Task.h b/TAO/tests/DII_Collocation_Tests/twoway/Server_Task.h new file mode 100644 index 00000000000..cd8b0582e6f --- /dev/null +++ b/TAO/tests/DII_Collocation_Tests/twoway/Server_Task.h @@ -0,0 +1,54 @@ +// -*- C++ -*- +// +// $Id$ + +#ifndef COLLOCATED_SERVER_TASK_H +#define COLLOCATED_SERVER_TASK_H + +#include /**/ "ace/pre.h" + +#include "ace/Task.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "tao/ORB.h" + +class ACE_Manual_Event; + +/// Implement a Task to run the server in a single thread +class Server_Task : public ACE_Task_Base +{ +public: + /// Constructor + Server_Task (const char *output, + const char *simple_test_output, + CORBA::ORB_ptr sorb, + ACE_Manual_Event &me, + ACE_Thread_Manager *thr_mgr); + + /// Thread entry point + int svc (void); + + CORBA::ULong error_count () const; + +private: + /// Output file for server IOR + const char *output_; + + /// Output file for Simple_Test IOR + const char *simple_test_output_; + + /// Manual event to wake up the main thread to create a client + /// thread. + ACE_Manual_Event &me_; + + CORBA::ORB_var sorb_; + + CORBA::ULong error_count_; +}; + +#include /**/ "ace/post.h" + +#endif /* COLLOCATED_SERVER_TASK_H */ diff --git a/TAO/tests/DII_Collocation_Tests/twoway/Test.idl b/TAO/tests/DII_Collocation_Tests/twoway/Test.idl new file mode 100644 index 00000000000..40cc4ecb9e5 --- /dev/null +++ b/TAO/tests/DII_Collocation_Tests/twoway/Test.idl @@ -0,0 +1,76 @@ +// +// $Id$ +// + +/// Put the interfaces in a module, to avoid global namespace pollution +module Test +{ + const unsigned long FIX_ARRAY_SIZE = 10; + const unsigned long VAR_ARRAY_SIZE = 3; + const unsigned long BOUNDED_STRING_SIZE = 10; + const unsigned long BOUNDED_VAR_SIZE = 10; + + typedef sequence<char, BOUNDED_VAR_SIZE> Bounded_Var_Size_Arg; + typedef sequence<char> Unbounded_Var_Size_Arg; + typedef long Fixed_Array[FIX_ARRAY_SIZE]; + typedef string Var_Array [VAR_ARRAY_SIZE]; + + struct TimeOfDay { + short hour; // 0 - 23 + short minute; // 0 - 59 + short second; // 0 - 59 + }; + + interface Simple_Test + { + void test_method(inout unsigned long error_count); + }; + + /// A very simple interface + interface Hello + { + void test_basic_arg(in long value); + + void test_unbounded_string_arg(in string message); + + void test_bounded_string_arg(in string<BOUNDED_STRING_SIZE> message); + + void test_fixed_array_arg(in Fixed_Array message); + + void test_var_array_arg(in Var_Array messages); + + void test_bounded_var_size_arg(in Bounded_Var_Size_Arg message); + + void test_unbounded_var_size_arg(in Unbounded_Var_Size_Arg message); + + void test_fixed_size_arg (in TimeOfDay t); + + void test_special_basic_arg(in char value); + + void test_objref_arg (in Simple_Test test); + + void test_object_arg (in Object o); + + void test_args_1 (in Object arg1, + in char arg2, + in Simple_Test arg3); + + void test_args_2 (in string arg1, + in Fixed_Array arg2, + in TimeOfDay arg3); + + void test_args_3 (in string<BOUNDED_STRING_SIZE> arg1, + in Bounded_Var_Size_Arg arg2, + in Unbounded_Var_Size_Arg arg3, + in Var_Array arg4); + + /// Return a simple string + string get_string (); + + /// A method to shutdown the ORB + /** + * This method is used to simplify the test shutdown process + */ + oneway void shutdown (); + }; +}; diff --git a/TAO/tests/DII_Collocation_Tests/twoway/run_test.pl b/TAO/tests/DII_Collocation_Tests/twoway/run_test.pl new file mode 100755 index 00000000000..592179ac316 --- /dev/null +++ b/TAO/tests/DII_Collocation_Tests/twoway/run_test.pl @@ -0,0 +1,77 @@ +eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' + & eval 'exec perl -S $0 $argv:q' + if 0; + +# $Id$ +# -*- perl -*- + +use lib '../../../../bin'; +use PerlACE::Run_Test; + +$iorfile = PerlACE::LocalFile ("test.ior"); +unlink $iorfile; +$status = 0; + +$SV = new PerlACE::Process ("Collocated_Test"); + +print STDERR "======== Running in Default Mode \n"; +$SV->Arguments ("-o $iorfile -k file://$iorfile"); +$sv = $SV->SpawnWaitKill (60); + +if ($sv != 0) { + print STDERR "ERROR in Collocated_Test\n"; + $status = 1; +} +unlink $iorfile; + +print STDERR "======== Running with per-orb \n"; +$SV->Arguments ("-o $iorfile -k file://$iorfile -ORBCollocation per-orb"); +$sv = $SV->SpawnWaitKill (60); + +if ($sv != 0) { + print STDERR "ERROR in Collocated_Test\n"; + $status = 1; +} +unlink $iorfile; + +print STDERR "======== Running with no collocation \n"; +$SV->Arguments ("-o $iorfile -k file://$iorfile -ORBCollocation no"); +$sv = $SV->SpawnWaitKill (60); + +if ($sv != 0) { + print STDERR "ERROR in Collocated_Test\n"; + $status = 1; +} +unlink $iorfile; + +print STDERR "======== Running in default mode and two ORBS \n"; +$SV->Arguments ("-o $iorfile -k file://$iorfile -n "); +$sv = $SV->SpawnWaitKill (60); + +if ($sv != 0) { + print STDERR "ERROR in Collocated_Test\n"; + $status = 1; +} +unlink $iorfile; + +print STDERR "======== Running in per-orb mode and two ORBS \n"; +$SV->Arguments ("-o $iorfile -k file://$iorfile -n -ORBCollocation per-orb"); +$sv = $SV->SpawnWaitKill (60); + +if ($sv != 0) { + print STDERR "ERROR in Collocated_Test\n"; + $status = 1; +} +unlink $iorfile; + +print STDERR "======== Running in no collocation mode and two ORBS \n"; +$SV->Arguments ("-o $iorfile -k file://$iorfile -n -ORBCollocation per-orb"); +$sv = $SV->SpawnWaitKill (60); + +if ($sv != 0) { + print STDERR "ERROR in Collocated_Test\n"; + $status = 1; +} +unlink $iorfile; + +exit $status; |