int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var tmp =
orb->string_to_object(ior);
Test::Hello_var hello =
Test::Hello::_narrow(tmp.in ());
if (CORBA::is_nil (hello.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil Test::Hello reference <%s>\n",
ior),
1);
}
CORBA::String_var the_string =
hello->get_string ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - string returned <%C>\n",
the_string.in ()));
hello->shutdown ();
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
if (expect_error)
{
ACE_DEBUG ((LM_DEBUG, "(%P|%t) client - expected exception occurred!\n%s\n",
ex._info().c_str()));
return 0;
}
else
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
}
if (expect_error)
{
ACE_DEBUG ((LM_ERROR, "(%P|%t) client - expected error did not occur!\n"));
return 1;
}
return 0;
}
int
Client_Task::svc (void)
{
try
{
CORBA::Object_var tmp =
this->corb_->string_to_object (input_);
Test::Hello_var hello =
Test::Hello::_narrow(tmp.in ());
if (CORBA::is_nil (hello.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil Test::Hello reference <%s>\n",
input_),
1);
}
CORBA::String_var the_string =
hello->get_string ();
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) - string returned <%C>\n",
the_string.in ()));
if (!this->result_)
{
// We would expect the call to fail, so we have an error now
ACE_ERROR ((LM_ERROR, "(%P|%t) - ERROR: get_string should have failed\n"));
}
hello->shutdown ();
}
catch (const CORBA::TRANSIENT& ex)
{
if (!this->result_)
{
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - caught expected exception\n"));
// When collocation has been disabled we expect a transient
// with minor code 2
return 0;
}
ex._tao_print_exception ("Caught exception:");
return 1;
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int
test_timeout (CORBA::Object_ptr object)
{
// Start the timer
profile_timer.start ();
try
{
// First connection happens here..
Test::Hello_var hello =
Test::Hello::_narrow(object);
if (CORBA::is_nil (hello.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil Test::Hello reference <%s>\n",
ior),
1);
}
CORBA::String_var the_string =
hello->get_string ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - string returned <%C>\n",
the_string.in ()));
hello->shutdown ();
}
catch (const CORBA::Exception&)
{
// Stop the timer
profile_timer.stop ();
// Get the elampsed time
ACE_Profile_Timer::ACE_Elapsed_Time el;
profile_timer.elapsed_time (el);
// Give a 30% error margin for handling exceptions etc. It is a
// high margin, though!. But the timeout is too small and wider
// range would help.
// The elapsed time is in secs
if (el.real_time > 0.200)
{
ACE_ERROR_RETURN ((LM_ERROR,
"(%P|%t) ERROR: Too long to timeout: %F\n",
el.real_time),
1);
}
else
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) Success, timeout: %F\n",
el.real_time));
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
int result = 0;
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var tmp = orb->string_to_object(ior);
Test::Hello_var hello = Test::Hello::_narrow(tmp.in ());
if (CORBA::is_nil (hello.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil Test::Hello reference <%s>\n",
ior),
1);
}
try
{
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - calling get_string\n"));
CORBA::String_var the_string = hello->get_string ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - string returned <%C>\n",
the_string.in ()));
ACE_OS::sleep (1);
hello->shutdown ();
}
catch (const CORBA::TRANSIENT& )
{
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - caught expected transient\n"));
result = 1;
}
catch (const CORBA::COMM_FAILURE& )
{
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - caught expected comm failure\n"));
}
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
result = 100;
}
return result;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var tmp = orb->string_to_object(ior);
Test::Hello_var hello = Test::Hello::_narrow(tmp.in ());
if (CORBA::is_nil (hello.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil Test::Hello reference <%s>\n",
ior),
1);
}
if (oneway_call)
{
CORBA::String_var the_string = CORBA::string_dup( "Test" );
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - Client sending string <%C> oneway\n",
the_string.in ()));
hello->set_string (the_string);
}
else
{
CORBA::String_var the_string = hello->get_string ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - Client getting string <%C>\n",
the_string.in ()));
}
hello->shutdown ();
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int
Client_Task::svc (void)
{
CORBA::Boolean exception = false;
try
{
CORBA::Object_var tmp =
this->corb_->string_to_object (input_);
Test::Hello_var hello =
Test::Hello::_narrow(tmp.in ());
if (CORBA::is_nil (hello.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil Test::Hello reference <%s>\n",
input_),
1);
}
try
{
CORBA::String_var the_string =
hello->get_string ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - string returned <%C>\n",
the_string.in ()));
hello->shutdown ();
}
catch (CORBA::INTERNAL)
{
exception = true;
ACE_DEBUG ((LM_DEBUG, "OK: Client_Task Expected exception received\n"));
corb_->destroy ();
return 0;
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
if (!exception)
{
ACE_ERROR ((LM_ERROR, "(ERROR: Client_Task::svc Expected exception not received\n"));
}
return 0;
}
int
Client_Task::svc (void)
{
int status = 1;
try
{
CORBA::Object_var tmp =
this->corb_->string_to_object (input_);
Test::Hello_var hello =
Test::Hello::_narrow(tmp.in ());
if (CORBA::is_nil (hello.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil Test::Hello reference <%s>\n",
input_),
1);
}
CORBA::String_var the_string =
hello->get_string ();
if (ACE_OS::strcmp (the_string.in (), "Hello there!") != 0)
{
ACE_ERROR ((LM_ERROR, "(%P|%t) - Error, incorrect string returned <%C>\n",
the_string.in ()));
status = 1;
}
else
{
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - string returned <%C>\n",
the_string.in ()));
}
hello->shutdown ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
status = 1;
}
return status;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var tmp =
orb->string_to_object(ior);
Test::Hello_var hello =
Test::Hello::_narrow(tmp.in ());
if (CORBA::is_nil (hello.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil Test::Hello reference <%s>\n",
ior),
1);
}
CORBA::String_var A = CORBA::string_dup ("DKWC");
CORBA::String_var B = CORBA::string_dup ("kwc");
CORBA::String_var C = CORBA::string_dup ("MV-files");
CORBA::String_var the_string =
hello->get_string (A.in (), B.in (), C.in ());
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - string returned <%C>\n",
the_string.in ()));
hello->shutdown ();
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
virtual int handle_timeout(const ACE_Time_Value &, const void *)
{
--iterationsLeft;
try
{
ACE_DEBUG ((LM_DEBUG,
"\n(%P|%t) - handling timeout with %d iterations left\n",
iterationsLeft + 1));
CORBA::Object_var tmp = orb->string_to_object(ior);
Test::Hello_var hello = Test::Hello::_narrow(tmp.in ());
if (CORBA::is_nil (hello.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil Test::Hello reference <%s>\n",
ior),
1);
}
CORBA::String_var the_string = hello->get_string ();
++successfulConnections;
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - string returned <%C>\n",
the_string.in ()));
ACE_OS::sleep(2);
hello->shutdown ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - shutdown requested\n"));
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
process_result = 1;
orb->shutdown();
}
if(successfulConnections == 2)
{
process_result = 0;
orb->shutdown();
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var tmp = orb->string_to_object(ior);
Test::Hello_var hello = Test::Hello::_narrow(tmp.in ());
if (CORBA::is_nil (hello.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil Test::Hello reference <%s>\n",
ior),
1);
}
CORBA::StringSeq my_seq (1);
my_seq.length (1);
hello->get_string (my_seq[0].out ());
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - string returned <%C>\n",
my_seq[0].in ()));
hello->shutdown ();
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int
Client_Task::svc (void)
{
try
{
CORBA::Object_var tmp = this->corb_->string_to_object (input_);
Test::Hello_var hello = Test::Hello::_narrow(tmp.in ());
if (CORBA::is_nil (hello.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil Test::Hello reference <%s>\n",
input_),
1);
}
CORBA::String_var the_string = hello->get_string ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - string returned <%C>\n",
the_string.in ()));
this->test_system_exception (hello.in ());
this->test_user_exception_expected (hello.in ());
this->test_user_exception_not_expected (hello.in ());
hello->shutdown ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int
Client_Worker::test_main (int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
ACE_ERROR_RETURN ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Could not parse the arguments\n")),
1);
// Doing this dance to allow the server some time to come up.
CORBA::Object_ptr co = 0;
for (int attempts_left = 5; attempts_left > 0; --attempts_left)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Client is ready to proceed - awaiting the server ...\n")));
ACE_OS::sleep (1);
try
{
co = orb->string_to_object (ior_file_.c_str ());
if (co == 0)
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Unable to obtain object reference yet. Retrying.\n")));
continue;
}
CORBA::Object_var tmp (co);
Test::Hello_var hello =
Test::Hello::_narrow(tmp.in ());
if (CORBA::is_nil (hello.in ()))
{
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Nil Test::Hello reference <%s>. Retrying.\n"),
ior_file_.c_str ()));
continue;
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Successfuly narrowed the Hello interface\n")));
CORBA::String_var the_string =
hello->get_string ();
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) String returned from the server <%C>\n"),
the_string.in ()));
hello->shutdown ();
attempts_left = 0; // We're done here!
}
catch (const CORBA::TRANSIENT& ex)
{
if (!attempts_left)
throw;
ex._tao_print_exception ("Temporary problem encountered");
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Client was too quick. Pausing ")
ACE_TEXT ("while the server gets ready.\n")));
ACE_OS::sleep (5);
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception("Unexpected CORBA exception caught");
if (!attempts_left)
throw;
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Pausing for a while.\n")));
ACE_OS::sleep (5);
}
}
orb->shutdown (0);
orb->destroy ();
}
catch (const ::CORBA::Exception &e)
{
e._tao_print_exception("Client_Worker::test_main");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var tmp = orb->string_to_object (ior);
// No remote calls, first request flag is on.
if (!first_request_flag (tmp.in ()))
{
ACE_ERROR ((LM_ERROR,
"Test FAILED at the beginning (why?)\n"));
}
// This call must issue LocateRequest message.
CORBA::PolicyList_var pl;
tmp->_validate_connection (pl.out ());
// There was a LocateRequest call, first request flag
// must be still on.
if (!first_request_flag (tmp.in ()))
{
ACE_ERROR ((LM_ERROR,
"Test FAILED after LocateRequest (bug#3676 is not fixed)!!\n"));
}
Test::Hello_var hello = Test::Hello::_narrow (tmp.in ());
if (CORBA::is_nil (hello.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil Test::Hello reference <%s>\n",
ior),
1);
}
CORBA::String_var the_string = hello->get_string ();
// Either _narrow or get_string issued a remote call,
// first request flag is off.
if (first_request_flag (tmp.in ()))
{
ACE_ERROR ((LM_ERROR,
"Test FAILED after normal request (why?)\n"));
}
hello->shutdown ();
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
int retval = 0;
try
{
PortableInterceptor::ORBInitializer_ptr temp_orb_initializer =
PortableInterceptor::ORBInitializer::_nil ();
PortableInterceptor::ORBInitializer_var orb_initializer;
// Register the ClientRequest_Interceptor ORBInitializer.
ACE_NEW_RETURN (temp_orb_initializer,
ClientORBInitializer,
-1);
orb_initializer = temp_orb_initializer;
PortableInterceptor::register_orb_initializer (orb_initializer.in ());
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var tmp =
orb->string_to_object (ior);
Test::Hello_var hello =
Test::Hello::_narrow(tmp.in () );
if (CORBA::is_nil (hello.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil Test::Hello reference <%s>\n",
ior),
1);
}
ACE_DEBUG ((LM_DEBUG, "Client about to make method call that is doomed to failure...\n"));
bool call_failed = false;
try
{
CORBA::String_var the_string =
hello->get_string ();
}
catch (const CORBA::Exception&)
{
call_failed = true;
}
if (!call_failed)
{
ACE_ERROR ((LM_ERROR,
"Error - the remote call succeeded which is bloody miraculous given that no server is running !!\n"));
++retval;
}
if (ClientRequest_Interceptor::success_flag_)
{
ACE_DEBUG ((LM_DEBUG, "Success - the server was unreachable and PI receive_exception was invoked.\n"));
}
else
{
ACE_ERROR ((LM_DEBUG,
"Error: regression failed - interceptor receive_exception interception point was not invoked !!\n"));
++retval;
}
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
++retval;
}
return retval;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
if (parse_args(argc, argv) != 0)
return 1;
// Get the RTORB.
CORBA::Object_var obj = orb->resolve_initial_references ("RTORB");
RTCORBA::RTORB_var rtorb = RTCORBA::RTORB::_narrow (obj.in());
//create the private connections policy. This means that every connection
// to the server uses his own socket.
CORBA::PolicyList policies (1);
policies.length (1);
policies[0] = rtorb->create_private_connection_policy ();
CORBA::Object_var pol_current_object = orb->resolve_initial_references ("PolicyCurrent");
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (pol_current_object.in ());
if (CORBA::is_nil (policy_current.in ()))
{
ACE_ERROR ((LM_ERROR, "ERROR: Nil policy current\n"));
return 1;
}
policy_current->set_policy_overrides (policies, CORBA::ADD_OVERRIDE);
Test::Hello_var *hello_array = 0;
ACE_NEW_RETURN (hello_array, Test::Hello_var [cache_size], -1);
int iter = 1;
for (iter = 1; iter <= cache_size; ++iter)
{
char object_string[256];
char reference_string[256];
ACE_OS::sprintf (reference_string, "TransportCacheTest%d", iter);
ACE_OS::sprintf (object_string, "corbaloc:iiop:localhost:%d/", port_nr);
ACE_OS::strcat (object_string, reference_string);
CORBA::Object_var hello_obj = orb->string_to_object (object_string);
orb->register_initial_reference (reference_string, hello_obj.in ());
CORBA::String_var ior_string = orb->object_to_string (hello_obj.in());
ACE_DEBUG((LM_DEBUG, ACE_TEXT("IOR string for reference %d : %C\n"),
iter, ior_string.in ()));
hello_array[iter-1] = Test::Hello::_narrow(hello_obj.in ());
}
//now we've got the references -> call each and everyone of them
for (iter = 0; iter < cache_size; ++iter)
{
Test::Hello_var hello = hello_array[iter];
if (CORBA::is_nil (hello.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
ACE_TEXT ("Nil Test::Hello reference\n")),
1);
}
CORBA::String_var the_string = hello->get_string ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - string returned <%C> from reference %d\n",
the_string.in (), iter + 1));
}
//shutdown the server
if (iter >= 0)
hello_array[0]->shutdown ();
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
ACE_Get_Opt opts (argc, argv, ACE_TEXT ("s:c:"));
const ACE_TCHAR *server = 0, *client = 0;
for (int o; (o = opts ()) != -1;)
{
switch (o)
{
case 's':
server = opts.opt_arg ();
break;
case 'c':
client = opts.opt_arg ();
break;
}
}
Servant srv (orb);
ORBTask task (orb);
if (server)
{
CORBA::Object_var obj = orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow (obj);
PortableServer::POAManager_var pm = poa->the_POAManager ();
pm->activate ();
Test::Hello_var srv_obj = srv._this ();
CORBA::String_var srv_str = orb->object_to_string (srv_obj);
FILE *f = ACE_OS::fopen (server, "w");
ACE_OS::fputs (srv_str, f);
ACE_OS::fclose (f);
if (!client)
task.activate();
}
if (client)
{
ACE_CString ior ("file://");
ior += ACE_TEXT_ALWAYS_CHAR (client);
CORBA::Object_var obj = orb->string_to_object (ior.c_str ());
Test::Hello_var hello = Test::Hello::_narrow (obj);
CORBA::String_var str = hello->get_string ();
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) - returned <%C>\n"),
str.in ()));
hello->shutdown ();
}
else if (server)
{
task.wait ();
}
orb->destroy ();
return 0;
}
catch (const CORBA::Exception &e)
{
e._tao_print_exception ("Exception caught:");
}
catch (...)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("ERROR unknown exception ")
ACE_TEXT ("caught in main\n")));
}
return 1;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb =
CORBA::ORB_init (argc, argv, "test");
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var tmp = orb->string_to_object(ior);
if (CORBA::is_nil (tmp.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR, "Invalid IOR.\n")
,1);
}
{
// Set the Synch Scopes
CORBA::Any scope_as_any;
if (synch_none == true)
{
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - Applying SYNC_NONE.\n"));
scope_as_any <<= Messaging::SYNC_NONE;
}
else if (synch_delayed == true)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) - Applying SYNC_DELAYED_BUFFERING.\n"));
scope_as_any <<= TAO::SYNC_DELAYED_BUFFERING;
}
CORBA::PolicyList policies (1);
policies.length (1);
policies[0] =
orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,
scope_as_any);
if (level_thread == true)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) - Applying Synch Scope at thread level.\n"));
CORBA::Object_var object =
orb->resolve_initial_references ("PolicyCurrent");
CORBA::PolicyCurrent_var policy_current =
CORBA::PolicyCurrent::_narrow (object.in ());
policy_current->set_policy_overrides (policies,
CORBA::ADD_OVERRIDE);
}
else if (level_orb == true)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) - Applying Synch Scope at orb level.\n"));
CORBA::Object_var obj =
orb->resolve_initial_references("ORBPolicyManager");
CORBA::PolicyManager_var policy_manager =
CORBA::PolicyManager::_narrow(obj.in());
policy_manager->set_policy_overrides (policies,
CORBA::ADD_OVERRIDE);
}
else if (level_obj == true)
{
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) - Applying Synch Scope at Object level.\n"));
tmp = tmp->_set_policy_overrides (policies, CORBA::SET_OVERRIDE);
}
policies[0]->destroy ();
}
Test::Hello_var hello =
Test::Hello::_narrow(tmp.in ());
if (CORBA::is_nil (hello.in ()))
{
ACE_ERROR_RETURN ((LM_ERROR,
"Nil Test::Hello reference <%s>\n",
ior),
1);
}
// If a blocking connection is initiated in the next step
// the test will get an exception indicating test failure.
// Be sure you IOR is for the localhost endpoint, else
// grab a book and wait around for timeout.
hello->get_string ();
TAO::Transport_Cache_Manager &tcm =
hello->orb_core ()->lane_resources ().transport_cache ();
TAO_Base_Transport_Property desc (hello->_stubobj ()->profile_in_use ()->endpoint ());
if (tcm.current_size() == 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
"The Transport Cache shouldn't be empty here.\n"),
1);
}
size_t busy_count = 0;
TAO_Transport *transport = 0;
TAO::Transport_Cache_Manager::Find_Result find_result =
tcm.find_transport (&desc, transport, busy_count);
// We don't need this transport any more. Release the ownership.
transport->remove_reference ();
switch (find_result){
case TAO::Transport_Cache_Manager::CACHE_FOUND_NONE:
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT("Expected to find a transport in the cache.\n")
),1);
}
case TAO::Transport_Cache_Manager::CACHE_FOUND_CONNECTING:
{
ACE_DEBUG (( LM_DEBUG,
ACE_TEXT ("Transport Cache contains connecting entry as expected.\n")
));
break; // that's what we expected
}
case TAO::Transport_Cache_Manager::CACHE_FOUND_BUSY:
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT("Cached Transport is busy. Should not happen because there's no server.\n")
),1);
}
case TAO::Transport_Cache_Manager::CACHE_FOUND_AVAILABLE:
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT("Cached Transport is available. Should not happen because there's no server.\n")
),1);
}
default:
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT("Transport_Cache::find returned unknown status.\n")
),1);
}
}
orb->destroy ();
}
catch (const CORBA::Exception &ex)
{
ACE_ERROR ((LM_ERROR, "ERROR: Exception caught: %s\"%s\"\n"
, ex._name(), ex._rep_id ()));
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var tmp =
orb->string_to_object("corbaloc:iiop:1.2@localhost:9931/NameService");
CosNaming::NamingContext_var root =
CosNaming::NamingContext::_narrow(tmp.in());
if (CORBA::is_nil (root.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil NamingService reference\n"),
1);
}
ACE_DEBUG ((LM_INFO, "**** Narrowed root NamingContext\n"));
CosNaming::Name name;
name.length(2);
name[0].id = CORBA::string_dup("example");
name[1].id = CORBA::string_dup("Hello");
try
{
tmp = root->resolve (name);
ACE_DEBUG ((LM_INFO, "**** Resolved #example/Hello\n"));
Test::Hello_var hello =
Test::Hello::_narrow(tmp.in ());
if (CORBA::is_nil (hello.in ()))
{
ACE_ERROR_RETURN ((LM_DEBUG,
"Nil Test::Hello reference\n"),
1);
}
CORBA::String_var the_string = hello->get_string ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - string returned <%C>\n",
the_string.in ()));
hello->shutdown ();
}
catch (const CosNaming::NamingContext::CannotProceed&)
{
ACE_DEBUG ((LM_DEBUG, "Caught correct exception\n"));
}
if (shutdown_nsmain)
{
CORBA::Object_var shutdowntmp = orb->string_to_object(ior);
Test::NsShutdown_var shutdown =
Test::NsShutdown::_narrow(shutdowntmp.in ());
ACE_DEBUG ((LM_DEBUG, "Shutdown nsmain\n"));
shutdown->shutdown ();
}
orb->shutdown ();
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
orb = CORBA::ORB_init (argc, argv);
CORBA::Object_var object =
orb->resolve_initial_references ("RTORB");
RTCORBA::RTORB_var rt_orb =
RTCORBA::RTORB::_narrow (object.in ());
// Set the tcp protocol properties
RTCORBA::TCPProtocolProperties_var tcp_properties =
rt_orb->create_tcp_protocol_properties (ACE_DEFAULT_MAX_SOCKET_BUFSIZ,
ACE_DEFAULT_MAX_SOCKET_BUFSIZ,
1, 0, 1, 0);
RTCORBA::ProtocolList protocols;
protocols.length (1);
protocols[0].protocol_type = 0;
protocols[0].transport_protocol_properties =
RTCORBA::ProtocolProperties::_duplicate (tcp_properties.in ());
protocols[0].orb_protocol_properties =
RTCORBA::ProtocolProperties::_nil ();
CORBA::PolicyList policy_list;
policy_list.length (1);
policy_list[0] =
rt_orb->create_client_protocol_policy (protocols);
object = orb->resolve_initial_references ("ORBPolicyManager");
CORBA::PolicyManager_var policy_manager =
CORBA::PolicyManager::_narrow (object.in ());
policy_manager->set_policy_overrides (policy_list,
CORBA::SET_OVERRIDE);
// start the failsafe thread. It will expire in 10 seconds and
// terminate with a failure if the following does not complete.
ACE_Thread::spawn (failsafe);
object = orb->string_to_object ("corbaloc::localhost:5678/Test");
Test::Hello_var hello = Test::Hello::_narrow(object.in());
is_ok = true;
test_lock.acquire ();
cond.signal();
test_lock.release ();
ACE_DEBUG ((LM_DEBUG, "SUCCESS: test did not spin.\n"));
CORBA::String_var the_string = hello->get_string ();
ACE_DEBUG ((LM_DEBUG, "(%P|%t) - string returned <%C>\n",
the_string.in ()));
hello->shutdown ();
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}