TAO/tests/Abstract_Interface/client.cpp

   1 // -*- C++ -*-
   2 #include "testC.h"
   3 #include "ace/Get_Opt.h"
   4
   5 const ACE_TCHAR *ior_input_file = ACE_TEXT ("file://test.ior");
   6 int debug = 0;
   7
   8 enum test_select
   9 {
  10   TEST_STATE,
  11   TEST_OPERATION,
  12   TEST_EXCEPTION,
  13   TEST_ALL
  14 };
  15
  16 test_select which_test = TEST_ALL;
  17
  18 int
  19 parse_args (int argc, ACE_TCHAR *argv[])
  20 {
  21   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("k:dsoe"));
  22   int c;
  23
  24   while ((c = get_opts ()) != -1)
  25     switch (c)
  26       {
  27       case 'k':
  28               ior_input_file = get_opts.optarg;
  29               break;
  30       case 'd':
  31               debug = 1;
  32               break;
  33       case 's':
  34               which_test = TEST_STATE;
  35               break;
  36       case 'o':
  37               which_test = TEST_OPERATION;
  38               break;
  39       case 'e':
  40               which_test = TEST_EXCEPTION;
  41               break;
  42       case '?':
  43       default:
  44         ACE_ERROR_RETURN ((LM_ERROR,
  45                            "usage:  %s "
  46                            "-k <iorfile>",
  47                            argv [0]),
  48                           -1);
  49       }
  50
  51   // Indicates successful parsing of the command line
  52   return 0;
  53 }
  54
  55 void
  56 dump_node (BaseNode* bn, int indent)
  57 {
  58   if (bn == 0)
  59     {
  60       return;
  61     }
  62
  63   StringNode* sn = StringNode::_downcast (bn);
  64
  65   if (debug)
  66     {
  67       // This is ugly I know
  68       int i = indent;
  69       for (; i != 0; --i) ACE_DEBUG ((LM_DEBUG, "  "));
  70
  71       if (sn != 0)
  72         {
  73           ACE_DEBUG ((LM_DEBUG, "%x <StringNode> %C\n",
  74                      bn,
  75                      sn->name ()));
  76         }
  77       else
  78         {
  79           ACE_DEBUG ((LM_DEBUG,
  80                       "%x <BaseNode>\n",
  81                       bn));
  82         }
  83     }
  84
  85   dump_node (bn->left (),
  86              indent + 1);
  87   dump_node (bn->right (),
  88              indent + 1);
  89 }
  90
  91 void
  92 dump_tree (TreeController *tc)
  93 {
  94   if (debug)
  95     {
  96       ACE_DEBUG ((LM_DEBUG,
  97                   "(%P|%t) start tree dump <%x>\n",
  98                   tc));
  99     }
 100
 101   dump_node (tc->root (),
 102              1);
 103
 104   if (debug)
 105     {
 106       ACE_DEBUG ((LM_DEBUG,
 107                   "(%P|%t) end tree dump <%x>\n",
 108                   tc));
 109     }
 110 }
 111
 112 void
 113 test_state (base_ptr abs)
 114 {
 115   CORBA::ValueBase_var vbase = abs->_to_value ();
 116   TreeController *tc = TreeController::_downcast (vbase.in ());
 117   dump_tree (tc);
 118 }
 119
 120 void
 121 test_operation (base_ptr abs)
 122 {
 123   CORBA::String_var retval = abs->base_op ("base_op");
 124
 125   if (debug)
 126     {
 127       ACE_DEBUG ((LM_DEBUG,
 128                   "%C\n",
 129                   retval.in ()));
 130     }
 131
 132   CORBA::Object_var obj = abs->_to_object ();
 133
 134   foo_var concrete = foo::_narrow (obj.in ());
 135
 136   retval = concrete->foo_op ("foo_op");
 137
 138   if (debug)
 139     {
 140       ACE_DEBUG ((LM_DEBUG,
 141                   "%C\n",
 142                   retval.in ()));
 143     }
 144
 145   retval = concrete->base_op ("base_op");
 146
 147   if (debug)
 148     {
 149       ACE_DEBUG ((LM_DEBUG,
 150                   "%C\n",
 151                   retval.in ()));
 152     }
 153 }
 154
 155 void
 156 test_exception (base_ptr abs)
 157 {
 158   try
 159     {
 160       CORBA::String_var retval = abs->base_op ("bad_name");
 161
 162       if (debug)
 163         {
 164           ACE_DEBUG ((LM_DEBUG,
 165                       "%C\n",
 166                       retval.in ()));
 167         }
 168     }
 169   catch (const BadInput& ex)
 170     {
 171       if (debug)
 172         {
 173           ACE_DEBUG ((LM_DEBUG,
 174                       "%C\n",
 175                       ex.message.in ()));
 176         }
 177     }
 178 }
 179
 180 int
 181 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
 182 {
 183   CORBA::String_var retval;
 184
 185   try
 186     {
 187       CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
 188
 189       if (parse_args (argc, argv) != 0)
 190         {
 191           return 1;
 192         }
 193
 194       CORBA::Object_var obj =
 195         orb->string_to_object (ior_input_file);
 196
 197       if (CORBA::is_nil (obj.in ()))
 198         {
 199           ACE_ERROR_RETURN ((LM_ERROR,
 200                              "string_to_object failed.\n"),
 201                             -1);
 202         }
 203
 204       passer_var objref = passer::_narrow (obj.in ());
 205
 206       if (CORBA::is_nil (objref.in ()))
 207         {
 208           ACE_ERROR_RETURN ((LM_ERROR,
 209                              "_narrow failed.\n"),
 210                             -1);
 211         }
 212
 213       base_var package = base::_nil ();
 214
 215       if (which_test == TEST_STATE || which_test == TEST_ALL)
 216         {
 217           // Create and register factory for BaseNode.
 218           BaseNode_init *bn_factory = 0;
 219           ACE_NEW_RETURN (bn_factory,
 220                           BaseNode_init,
 221                           1);
 222
 223           orb->register_value_factory (bn_factory->tao_repository_id (),
 224                                        bn_factory);
 225           bn_factory->_remove_ref (); // release ownership
 226
 227           // Create and register factory for TreeController.
 228           TreeController_init *tc_factory = 0;
 229           ACE_NEW_RETURN (tc_factory,
 230                           TreeController_init,
 231                           1);
 232
 233           orb->register_value_factory (tc_factory->tao_repository_id (),
 234                                        tc_factory);
 235           tc_factory->_remove_ref (); // release ownership
 236
 237           // Create and register factory for StringNode.
 238           StringNode_init *sn_factory = 0;
 239           ACE_NEW_RETURN (sn_factory,
 240                           StringNode_init,
 241                           1);
 242
 243           orb->register_value_factory (sn_factory->tao_repository_id (),
 244                                        sn_factory);
 245           sn_factory->_remove_ref (); // release ownership
 246
 247           objref->pass_state (package.out ());
 248
 249           if (CORBA::is_nil (package.in ()))
 250             {
 251               ACE_ERROR_RETURN ((LM_ERROR,
 252                                  "pass_state() returned null OUT arg\n"),
 253                                 -1);
 254             }
 255
 256           test_state (package.in ());
 257         }
 258
 259       if (which_test != TEST_STATE)
 260         {
 261           objref->pass_ops (package.out ());
 262
 263           if (CORBA::is_nil (package.in ()))
 264             {
 265               ACE_ERROR_RETURN ((LM_ERROR,
 266                                  "pass_ops() returned null OUT arg\n"),
 267                                 -1);
 268             }
 269         }
 270
 271       if (which_test == TEST_OPERATION || which_test == TEST_ALL)
 272         {
 273           test_operation (package.in ());
 274         }
 275
 276       if (which_test == TEST_EXCEPTION || which_test == TEST_ALL)
 277         {
 278           test_exception (package.in ());
 279         }
 280
 281       if (which_test == TEST_ALL)
 282         {
 283           objref->pass_nil (package.out ());
 284
 285           if (!CORBA::is_nil (package.in ()))
 286             {
 287               ACE_ERROR_RETURN ((LM_ERROR,
 288                                  "pass_nil() did NOT return null OUT arg\n"),
 289                                 -1);
 290             }
 291         }
 292
 293       objref->shutdown ();
 294
 295       orb->destroy ();
 296     }
 297   catch (const CORBA::Exception& ex)
 298     {
 299       ex._tao_print_exception ("Client: exception caught - ");
 300
 301       return 1;
 302     }
 303
 304   return 0;
 305 }