TAO/tests/Bug_3919_Regression/client.cpp

   1 #include "Test2C.h"
   2 #include "tao/IFR_Client/IFR_BaseC.h"
   3 #include "tao/TypeCodeFactory/TypeCodeFactory_Loader.h"
   4
   5 #include "ace/Get_Opt.h"
   6
   7 #include <algorithm>
   8 #include <functional>
   9
  10 const ACE_TCHAR *ior = ACE_TEXT("file://test.ior");
  11
  12 int
  13 parse_args (int argc, ACE_TCHAR *argv[])
  14 {
  15   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("k:"));
  16   int c;
  17
  18   while ((c = get_opts ()) != -1)
  19     switch (c)
  20       {
  21       case 'k':
  22         ior = get_opts.opt_arg ();
  23         break;
  24
  25       case '?':
  26       case 'h':
  27       default:
  28         ACE_ERROR_RETURN ((LM_ERROR,
  29                            "usage:  %s "
  30                            "-k <ior> "
  31                            "\n",
  32                            argv [0]),
  33                           -1);
  34       }
  35
  36   // Successful command line parsing.
  37   return 0;
  38 }
  39
  40 template<typename T> void dump (T *); // Forward declaration.
  41
  42 template<typename T>
  43 void
  44 perform_invocation (Test::Hello_ptr hello,
  45                     CORBA::Any const & the_any)
  46 {
  47   // Execute more than once to help verify that mutable recursive
  48   // TypeCode state is managed correctly.
  49   for (unsigned int n = 0; n < 2; ++n)
  50     {
  51       CORBA::Any_var my_any =
  52         hello->get_any (the_any);
  53
  54       const T * my_foo = 0;
  55       if (!(my_any.in () >>= my_foo))
  56         throw Test::Demarshaling_From_Any_Failed ();
  57
  58       CORBA::TypeCode_var the_tc = the_any.type ();
  59       CORBA::TypeCode_var my_tc  = my_any->type ();
  60
  61       CORBA::Boolean const equal_tc =
  62         the_tc->equal (my_tc.in ());
  63
  64       if (!equal_tc)
  65         throw Test::Recursive_Type_In_Any_Test_Failed ();
  66
  67       CORBA::Boolean const equiv_tc =
  68         the_tc->equivalent (my_tc.in ());
  69
  70       if (!equiv_tc)
  71         throw Test::Recursive_Type_In_Any_Test_Failed ();
  72     }
  73 }
  74
  75 void
  76 recursive_typecode_test (CORBA::ORB_ptr /* orb */,
  77                               Test::Hello_ptr hello)
  78 {
  79   ACE_DEBUG ((LM_INFO,
  80               "Executing recursive typecode test\n"));
  81
  82   CORBA::Any the_any;
  83
  84   Test::MyAttRefSequence test;
  85
  86   Test::MyAttRef attr;
  87   attr.attRefName="attr";
  88   attr.attRefValue.attrValue("value");
  89   attr.attRefQualifier="atrQ1";
  90
  91   Test::MyAttRef attr2;
  92   attr2.attRefName="attr2";
  93   attr2.attRefValue.attrValue("value2");
  94   attr2.attRefQualifier="atrQ2";
  95
  96   Test::MyAttRef comp;
  97   comp.attRefName="comp1";
  98   comp.attRefQualifier="compQ";
  99
 100   Test::MyAttRef::MyAttRefValue::_compValue_seq compSeq(1);
 101   compSeq.length(1);
 102   compSeq[0]=attr2;
 103   comp.attRefValue.compValue(compSeq);
 104
 105   Test::MyAttRef inti;
 106   inti.attRefName="intval";
 107   inti.attRefValue.intValue(0xAFFEAFFE);
 108
 109   test.length(3);
 110   test[0] = comp;
 111   test[1] = inti;
 112   test[2] = attr;
 113
 114   the_any <<= test;
 115
 116   ::perform_invocation<Test::MyAttRefSequence> (hello, the_any);
 117
 118 }
 119
 120 void
 121 nested_recursive_typecode_test (CORBA::ORB_ptr /* orb */,
 122                               Test::Hello_ptr hello)
 123 {
 124   ACE_DEBUG ((LM_INFO,
 125               "Executing nested recursive typecode test\n"));
 126
 127   CORBA::Any the_any;
 128
 129   Test2::MyAttRefSeqStruct test;
 130
 131   Test::MyAttRef attr;
 132   attr.attRefName="attr";
 133   attr.attRefValue.attrValue("value");
 134   attr.attRefQualifier="atrQ1";
 135
 136   Test::MyAttRef attr2;
 137   attr2.attRefName="attr2";
 138   attr2.attRefValue.attrValue("value2");
 139   attr2.attRefQualifier="atrQ2";
 140
 141   Test::MyAttRef comp;
 142   comp.attRefName="comp1";
 143   comp.attRefQualifier="compQ";
 144
 145   Test::MyAttRef::MyAttRefValue::_compValue_seq compSeq(1);
 146   compSeq.length(1);
 147   compSeq[0]=attr2;
 148   comp.attRefValue.compValue(compSeq);
 149
 150   Test::MyAttRef inti;
 151   inti.attRefName="intval";
 152   inti.attRefValue.intValue(0xAFFEAFFE);
 153
 154   test.attRefSeq.length(3);
 155   test.attRefSeq[0] = comp;
 156   test.attRefSeq[1] = inti;
 157   test.attRefSeq[2] = attr;
 158
 159   the_any <<= test;
 160
 161   ::perform_invocation<Test2::MyAttRefSeqStruct> (hello, the_any);
 162
 163 }
 164
 165 /**
 166  * @struct Caller
 167  *
 168  * @brief Test method invocation functor.
 169  *
 170  * Test method invocation functor.
 171  */
 172 template <typename T>
 173 struct Caller : public std::unary_function<T, void>
 174 {
 175   /// Constructor.
 176   Caller (CORBA::ORB_ptr o, Test::Hello_ptr h)
 177     : orb (CORBA::ORB::_duplicate (o))
 178     , hello (Test::Hello::_duplicate (h))
 179     , success (true)
 180   {
 181   }
 182
 183   /// Function call operator overload.
 184   void operator() (T f)
 185   {
 186     try
 187       {
 188         f (orb.in (),
 189            hello.in ());
 190       }
 191     catch (const CORBA::Exception& ex)
 192       {
 193         ex._tao_print_exception ("Exception thrown:");
 194
 195         success = false;
 196       }
 197   }
 198
 199   CORBA::ORB_var orb;
 200   Test::Hello_var hello;
 201   bool success;
 202 };
 203
 204 int
 205 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 206 {
 207   try
 208     {
 209       CORBA::ORB_var orb =
 210         CORBA::ORB_init (argc, argv);
 211
 212       if (parse_args (argc, argv) != 0)
 213         return 1;
 214
 215       CORBA::Object_var tmp =
 216         orb->string_to_object(ior);
 217
 218       Test::Hello_var hello =
 219         Test::Hello::_narrow(tmp.in ());
 220
 221       if (CORBA::is_nil (hello.in ()))
 222         {
 223           ACE_ERROR_RETURN ((LM_DEBUG,
 224                              "Nil Test::Hello reference <%s>\n",
 225                              ior),
 226                             1);
 227         }
 228
 229       typedef void (*test_func) (CORBA::ORB_ptr,
 230                                  Test::Hello_ptr);
 231
 232       static test_func const tests[] =
 233         {
 234           recursive_typecode_test,
 235           nested_recursive_typecode_test
 236         };
 237
 238       static size_t const test_count = sizeof (tests) / sizeof (test_func);
 239
 240       // Have some fun with the STL.  :-)
 241       Caller<test_func> c =
 242         std::for_each (tests,
 243                        tests + test_count,
 244                        Caller<test_func> (orb.in (),
 245                                           hello.in ()));
 246
 247       if (!c.success)
 248         throw Test::Recursive_Type_In_Any_Test_Failed ();
 249
 250       hello->shutdown ();
 251
 252       orb->destroy ();
 253     }
 254   catch (const CORBA::Exception& ex)
 255     {
 256       ex._tao_print_exception ("Exception caught:");
 257       return 1;
 258     }
 259
 260   return 0;
 261 }