TAO/tests/OBV/Any/client.cpp

   1 #include "AnyC.h"
   2 #include "ace/Get_Opt.h"
   3
   4 const ACE_TCHAR *ior = ACE_TEXT("file://test.ior");
   5
   6 int
   7 parse_args (int argc, ACE_TCHAR *argv[])
   8 {
   9   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("k:"));
  10   int c;
  11
  12   while ((c = get_opts ()) != -1)
  13     switch (c)
  14       {
  15       case 'k':
  16         ior = get_opts.optarg;
  17         break;
  18
  19       case '?':
  20       default:
  21         ACE_ERROR_RETURN ((LM_ERROR,
  22                            "usage:  %s "
  23                            "-k <ior> "
  24                            "\n",
  25                            argv [0]),
  26                           -1);
  27       }
  28   // Indicates successful parsing of the command line
  29   return 0;
  30 }
  31
  32 int
  33 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
  34 {
  35   try
  36     {
  37
  38       ACE_DEBUG ((LM_DEBUG, "(%P|%t) client - test started.\n"));
  39
  40       CORBA::ORB_var orb =
  41         CORBA::ORB_init (argc, argv);
  42
  43       if (parse_args (argc, argv) != 0)
  44         return 1;
  45
  46       // Create and register factories.
  47
  48       OBV_AnyTest::VA_init *va_factory = 0;
  49       ACE_NEW_RETURN (va_factory,
  50                       OBV_AnyTest::VA_init,
  51                       1); // supplied by mapping
  52
  53       orb->register_value_factory (va_factory->tao_repository_id (),
  54                                    va_factory);
  55       va_factory->_remove_ref (); // release ownership
  56
  57
  58       OBV_AnyTest::VB_init *vb_factory = 0;
  59       ACE_NEW_RETURN (vb_factory,
  60                       OBV_AnyTest::VB_init,
  61                       1); // supplied by mapping
  62
  63       orb->register_value_factory (vb_factory->tao_repository_id (),
  64                                    vb_factory);
  65       vb_factory->_remove_ref (); // release ownership
  66
  67       // Do local test
  68
  69       OBV_AnyTest::VA_var va1, va2;
  70       ACE_NEW_RETURN (va1.inout (), OBV_OBV_AnyTest::VA, 1);
  71       ACE_NEW_RETURN (va2.inout (), OBV_OBV_AnyTest::VA, 1);
  72
  73       const CORBA::ULong magic = 3145;
  74
  75       va1->id (magic);
  76       va2->id (magic);
  77
  78       CORBA::Any a1, a2;
  79
  80       // Test both copying and non-copying version of operator<<=
  81       a1 <<= va1.in ();
  82
  83       OBV_AnyTest::VA *pva = va2._retn();
  84       a2 <<= &pva;
  85
  86       OBV_AnyTest::VA* dst = 0;
  87
  88       if (!(a1 >>= dst) || dst->id () != magic)
  89         {
  90           ACE_ERROR_RETURN ((LM_DEBUG,
  91                              "(%P|%t) client - test failed.\n"),
  92                             1);
  93         }
  94
  95       if (!(a2 >>= dst) || dst->id () != magic)
  96         {
  97           ACE_ERROR_RETURN ((LM_DEBUG,
  98                              "(%P|%t) client - test failed.\n"),
  99                             1);
 100         }
 101
 102
 103       // It should be possible to extract to a base type
 104       OBV_AnyTest::VB_var vb1;
 105       ACE_NEW_RETURN (vb1.inout (), OBV_OBV_AnyTest::VB, 1);
 106       vb1->id (magic);
 107
 108       a1 <<= vb1.in ();
 109       CORBA::ValueBase_var target;
 110       if (!(a1 >>= CORBA::Any::to_value(target.out())))
 111         {
 112           ACE_ERROR_RETURN ((LM_DEBUG,
 113                              "(%P|%t) client - base extraction test failed.\n"),
 114                             1);
 115         }
 116       dst = OBV_AnyTest::VA::_downcast(target.in());
 117       if (dst == 0 || dst->id() != magic)
 118         {
 119           ACE_ERROR_RETURN ((LM_DEBUG,
 120                              "(%P|%t) client - base extraction test failed.\n"),
 121                             1);
 122         }
 123
 124
 125       // Now do remote test
 126
 127       CORBA::Object_var tmp =
 128         orb->string_to_object(ior);
 129
 130       OBV_AnyTest::Test_var test =
 131         OBV_AnyTest::Test::_narrow(tmp.in ());
 132
 133       if (CORBA::is_nil (test.in ()))
 134       {
 135         ACE_ERROR_RETURN ((LM_DEBUG,
 136                          "Nil OBV_AnyTest::Test reference <%s>\n",
 137                          ior),
 138                         1);
 139       }
 140
 141
 142       // STEP 1.
 143       CORBA::Any_var result = test->get_something (
 144           0);
 145
 146       if (!(result.inout () >>= dst) || dst->id () != magic)
 147         {
 148           ACE_ERROR_RETURN ((LM_DEBUG,
 149                              "(%P|%t) client - test 1 failed.\n"),
 150                             1);
 151         }
 152
 153       // STEP 2.
 154       OBV_AnyTest::VB* dst_vb = 0;
 155       result = test->get_something (
 156           1);
 157
 158       if (!(result.inout () >>= dst_vb) || dst_vb->id () != magic)
 159         {
 160           ACE_ERROR_RETURN ((LM_DEBUG,
 161                              "(%P|%t) client - test 2 failed.\n"),
 162                             1);
 163         }
 164
 165       // STEP 3. A sanity check demonstrating base-type pointer to
 166       // derived type allowed.
 167       OBV_AnyTest::VA_var dst_va = test->get_vb();
 168       if (dst_va->id () != magic)
 169         {
 170           ACE_ERROR_RETURN ((LM_DEBUG,
 171                              "(%P|%t) client - test 3 failed.\n"),
 172                             1);
 173         }
 174
 175 #if !defined (TAO_HAS_OPTIMIZED_VALUETYPE_MARSHALING)
 176       // @@ There's still a problem here with the optimized valuetype
 177       // marshaling and passing values through anys. The problem is
 178       // that while the Any in fact contains all of the required type
 179       // information, there is no way to share that with the
 180       // ValueBase::_tao_unmarshal_pre() which needs the type info in
 181       // order to select the appropriate value factory.
 182
 183       // STEP 4. get a VB, but extract to a VA*.
 184       result = test->get_something (
 185           1);
 186
 187       if (!(result.inout () >>= CORBA::Any::to_value(target.out())))
 188         {
 189           ACE_ERROR_RETURN ((LM_DEBUG,
 190                              "(%P|%t) client - test 4 extraction failed.\n"),
 191                             1);
 192         }
 193       dst_va = OBV_AnyTest::VA::_downcast(target._retn());
 194       if (dst_va == 0 || dst_va->id() != magic)
 195         {
 196           ACE_ERROR_RETURN ((LM_DEBUG,
 197                              "(%P|%t) client -  test 4 failed.\n"),
 198                             1);
 199         }
 200 #endif /* TAO_HAS_OPTIMIZED_VALUETYPE_MARSHALING */
 201
 202       test->shutdown ();
 203
 204       orb->destroy ();
 205
 206       ACE_DEBUG ((LM_DEBUG, "(%P|%t) client - test finished.\n"));
 207     }
 208   catch (const CORBA::Exception& ex)
 209     {
 210       ex._tao_print_exception ("Exception caught in client:");
 211       return 1;
 212     }
 213
 214   return 0;
 215 }