TAO/tests/IDL_Test/main.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    main.cpp
   5  *
   6  *  We test the pragma prefixes generated in pragma.idl, and
   7  *  the values of some generated constants in constants.idl.
   8  *
   9  *  @author Jeff Parsons <parsons@cs.wustl.edu>
  10  */
  11 //=============================================================================
  12
  13
  14 #include "pragmaS.h"
  15 #include "unionC.h"
  16 #include "repo_id_modC.h"
  17 #include "constantsC.h"
  18 #include "nested_scopeS.h"
  19 #include "typedefC.h"
  20 #include "expressionsC.h"
  21
  22 #include "ace/Log_Msg.h"
  23 #include "ace/OS_NS_string.h"
  24 #include "tao/AnyTypeCode/Any.h"
  25
  26 class hello_i : public virtual POA_hello
  27 {
  28 };
  29
  30 class goodbye_i : public virtual POA_goodbye
  31 {
  32 };
  33
  34 class sayonara_i : public virtual POA_salutation::sayonara
  35 {
  36 };
  37
  38 class ciao_i : public virtual POA_ciao
  39 {
  40 };
  41
  42 class aloha_i : public virtual POA_aloha
  43 {
  44 };
  45
  46 class schmooze_i : public virtual gleep::schmooze
  47 {
  48 };
  49
  50 class schmeer_i : public virtual gleep::schmeer
  51 {
  52 };
  53
  54 class schlemiel_i : public virtual gleep::schlemiel
  55 {
  56 };
  57
  58 class spilkis_i : public virtual gleep::spilkis
  59 {
  60 };
  61
  62 class schmuck_i : public virtual gleep::floop::schmuck
  63 {
  64 };
  65
  66 class schmendrick_i : public virtual gleep::floop::schmendrick
  67 {
  68 };
  69
  70 class schlemazel_i : public virtual gleep::floop::verklempt::schlemazel
  71 {
  72 };
  73
  74 class schmegegging_i : public virtual gleep::schmegegging
  75 {
  76 };
  77
  78 struct something_handler
  79   : public POA_bug_1985_c::d::AMI_somethingHandler
  80 {
  81 };
  82
  83 template <typename Type>
  84 void
  85 expect_equals (int &error_count, const char *name, Type actual, Type expected)
  86 {
  87   if (actual != expected)
  88     {
  89       *ACE_DEFAULT_LOG_STREAM
  90         << "ERROR: For " << name << " expected: " << expected
  91         << ", but got " << actual << "\n";
  92       ++error_count;
  93     }
  94 }
  95
  96 void
  97 test_expressions (int &error_count)
  98 {
  99   expect_equals<CORBA::Short> (error_count, "ShortValues::a", ShortValues::a, 6);
 100   expect_equals<CORBA::Short> (error_count, "ShortValues::b", ShortValues::b, 3);
 101   expect_equals<CORBA::Short> (error_count, "ShortValues::div", ShortValues::div, 2);
 102   expect_equals<CORBA::Short> (error_count, "ShortValues::mul", ShortValues::mul, 18);
 103   expect_equals<CORBA::Short> (error_count, "ShortValues::add", ShortValues::add, 9);
 104   expect_equals<CORBA::Short> (error_count, "ShortValues::sub", ShortValues::sub, 3);
 105   expect_equals<CORBA::Short> (error_count, "ShortValues::mod", ShortValues::mod, 0);
 106
 107   expect_equals<CORBA::Long> (error_count, "LongValues::a", LongValues::a, 6);
 108   expect_equals<CORBA::Long> (error_count, "LongValues::b", LongValues::b, 3);
 109   expect_equals<CORBA::Long> (error_count, "LongValues::div", LongValues::div, 2);
 110   expect_equals<CORBA::Long> (error_count, "LongValues::mul", LongValues::mul, 18);
 111   expect_equals<CORBA::Long> (error_count, "LongValues::add", LongValues::add, 9);
 112   expect_equals<CORBA::Long> (error_count, "LongValues::sub", LongValues::sub, 3);
 113   expect_equals<CORBA::Long> (error_count, "LongValues::mod", LongValues::mod, 0);
 114
 115   expect_equals<CORBA::Long> (error_count, "MixedIntValues::div", MixedIntValues::div, 2);
 116   expect_equals<CORBA::Long> (error_count, "MixedIntValues::mul", MixedIntValues::mul, 18);
 117   expect_equals<CORBA::Long> (error_count, "MixedIntValues::add", MixedIntValues::add, 9);
 118   expect_equals<CORBA::Long> (error_count, "MixedIntValues::sub", MixedIntValues::sub, 3);
 119   expect_equals<CORBA::Long> (error_count, "MixedIntValues::mod", MixedIntValues::mod, 0);
 120
 121   expect_equals<CORBA::Float> (error_count, "FloatValues::a", FloatValues::a, 6.0f);
 122   expect_equals<CORBA::Float> (error_count, "FloatValues::b", FloatValues::b, 3.0f);
 123   expect_equals<CORBA::Float> (error_count, "FloatValues::div", FloatValues::div, 2.0f);
 124   expect_equals<CORBA::Float> (error_count, "FloatValues::mul", FloatValues::mul, 18.0f);
 125   expect_equals<CORBA::Float> (error_count, "FloatValues::add", FloatValues::add, 9.0f);
 126   expect_equals<CORBA::Float> (error_count, "FloatValues::sub", FloatValues::sub, 3.0f);
 127
 128   expect_equals<CORBA::Double> (error_count, "DoubleValues::a", DoubleValues::a, 6.0);
 129   expect_equals<CORBA::Double> (error_count, "DoubleValues::b", DoubleValues::b, 3.0);
 130   expect_equals<CORBA::Double> (error_count, "DoubleValues::div", DoubleValues::div, 2.0);
 131   expect_equals<CORBA::Double> (error_count, "DoubleValues::mul", DoubleValues::mul, 18.0);
 132   expect_equals<CORBA::Double> (error_count, "DoubleValues::add", DoubleValues::add, 9.0);
 133   expect_equals<CORBA::Double> (error_count, "DoubleValues::sub", DoubleValues::sub, 3.0);
 134
 135   expect_equals<CORBA::Double> (error_count, "MixedFloatValues::div", MixedFloatValues::div, 2.0);
 136   expect_equals<CORBA::Double> (error_count, "MixedFloatValues::mul", MixedFloatValues::mul, 18.0);
 137   expect_equals<CORBA::Double> (error_count, "MixedFloatValues::add", MixedFloatValues::add, 9.0);
 138   expect_equals<CORBA::Double> (error_count, "MixedFloatValues::sub", MixedFloatValues::sub, 3.0);
 139 }
 140
 141 int
 142 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
 143 {
 144   int error_count = 0;
 145
 146   const ACE_CDR::ULongLong test_ull =
 147     ACE_UINT64_LITERAL (122192928000000000);
 148
 149   if (test_ull != AAA)
 150     {
 151       ++error_count;
 152       ACE_ERROR ((LM_ERROR,
 153                   ACE_TEXT ("Generated value of unsigned")
 154                   ACE_TEXT (" long long AAA in constants.idl")
 155                   ACE_TEXT (" is incorrect\n")));
 156     }
 157
 158   const CORBA::LongLong test_nll = ACE_INT64_LITERAL (-122192928000000000);
 159
 160   if (test_nll != NAAA)
 161     {
 162       ++error_count;
 163       ACE_ERROR ((LM_ERROR,
 164                   ACE_TEXT ("Generated value of signed")
 165                   ACE_TEXT (" long long NAAA in constants.idl")
 166                   ACE_TEXT (" is incorrect\n")));
 167     }
 168
 169   const CORBA::LongLong test_pll = ACE_INT64_LITERAL (122192928000000000);
 170
 171   if (test_pll != PAAA)
 172     {
 173       ++error_count;
 174       ACE_ERROR ((LM_ERROR,
 175                   ACE_TEXT ("Generated value of signed")
 176                   ACE_TEXT (" long long PAAA in constants.idl")
 177                   ACE_TEXT (" is incorrect\n")));
 178     }
 179
 180   try
 181     {
 182       CORBA::ORB_var orb = CORBA::ORB_init (argc,
 183                                             argv);
 184
 185       CORBA::Object_var poa_object =
 186         orb->resolve_initial_references ("RootPOA");
 187
 188       PortableServer::POA_var root_poa =
 189         PortableServer::POA::_narrow (poa_object.in ());
 190
 191       // Test of #pragma prefix behavior.
 192
 193       CORBA::Object_var obj;
 194
 195       hello_i h;
 196       PortableServer::ObjectId_var id = root_poa->activate_object (&h);
 197       obj = root_poa->id_to_reference (id.in ());
 198       obj = hello::_narrow (obj.in ());
 199
 200       if (ACE_OS::strcmp (obj->_interface_repository_id (),
 201                           "IDL:anvil.com/hello:1.0"))
 202         {
 203           ++error_count;
 204           ACE_ERROR ((LM_ERROR,
 205                       "pragma prefix error in object 'hello'\n"));
 206         }
 207
 208       goodbye_i g;
 209       id = root_poa->activate_object (&g);
 210       obj = root_poa->id_to_reference (id.in ());
 211       obj = goodbye::_narrow (obj.in ());
 212
 213       if (ACE_OS::strcmp (obj->_interface_repository_id (),
 214                           "IDL:anvil.com/goodbye:1.0"))
 215         {
 216           ++error_count;
 217           ACE_ERROR ((LM_ERROR,
 218                       "pragma prefix error in object 'goodbye'\n"));
 219         }
 220
 221       sayonara_i s;
 222       id = root_poa->activate_object (&s);
 223       obj = root_poa->id_to_reference (id.in ());
 224       obj = salutation::sayonara::_narrow (obj.in ());
 225
 226       if (ACE_OS::strcmp (obj->_interface_repository_id (),
 227                           "IDL:hammer.com/salutation/sayonara:1.0"))
 228         {
 229           ++error_count;
 230           ACE_ERROR ((LM_ERROR,
 231                       "pragma prefix error in object 'sayonara'\n"));
 232         }
 233
 234       // Check whether the implementation of Dubble and Toil are generated
 235       CommaList::Dubble dub;
 236       CommaList::Toil toi;
 237       dub.length (4);
 238       toi.length (4);
 239
 240       ciao_i c;
 241       id = root_poa->activate_object (&c);
 242       obj = root_poa->id_to_reference (id.in ());
 243       obj = ciao::_narrow (obj.in ());
 244
 245       if (ACE_OS::strcmp (obj->_interface_repository_id (),
 246                           "IDL:anvil.com/ciao:1.0"))
 247         {
 248           ++error_count;
 249           ACE_ERROR ((LM_ERROR,
 250                       "pragma prefix error in object 'ciao'\n"));
 251         }
 252
 253       aloha_i a;
 254       id = root_poa->activate_object (&a);
 255       obj = root_poa->id_to_reference (id.in ());
 256       obj = aloha::_narrow (obj.in ());
 257
 258       if (ACE_OS::strcmp (obj->_interface_repository_id (),
 259                           "IDL:anvil.com/aloha:1.0"))
 260         {
 261           ++error_count;
 262           ACE_ERROR ((LM_ERROR,
 263                       "pragma prefix error in object 'aloha'\n"));
 264         }
 265
 266       // Test of typeprefix, typeid, and #pragma version behavior.
 267
 268       schmooze_i s_schmooze;
 269
 270       if (ACE_OS::strcmp (s_schmooze._interface_repository_id (),
 271                           "IDL:gleep_prefix/gleep/schmooze:1.0"))
 272         {
 273           ++error_count;
 274           ACE_ERROR ((LM_ERROR,
 275                       "pragma prefix error in object 'schmooze'\n"));
 276         }
 277
 278       schmeer_i s_schmeer;
 279
 280       if (ACE_OS::strcmp (s_schmeer._interface_repository_id (),
 281                           "IDL:gleep_prefix/gleep/schmeer:1.0"))
 282         {
 283           ++error_count;
 284           ACE_ERROR ((LM_ERROR,
 285                       "pragma prefix error in object 'schmeer'\n"));
 286         }
 287
 288       schlemiel_i s_schlemiel;
 289
 290       if (ACE_OS::strcmp (s_schlemiel._interface_repository_id (),
 291                           "IDL:gleep_prefix/gleep/schlemiel:1.0"))
 292         {
 293           ++error_count;
 294           ACE_ERROR ((LM_ERROR,
 295                       "pragma prefix error in object 'schlemiel'\n"));
 296         }
 297
 298       spilkis_i s_spilkis;
 299
 300       if (ACE_OS::strcmp (s_spilkis._interface_repository_id (),
 301                           "IDL:gleep_prefix/gleep/spilkis:1.0"))
 302         {
 303           ++error_count;
 304           ACE_ERROR ((LM_ERROR,
 305                       "pragma prefix error in object 'spilkis'\n"));
 306         }
 307
 308       schmuck_i s_schmuck;
 309
 310       if (ACE_OS::strcmp (s_schmuck._interface_repository_id (),
 311                           "ABRA:cadabra/hocus/pocus:1.23"))
 312         {
 313           ++error_count;
 314           ACE_ERROR ((LM_ERROR,
 315                       "pragma prefix error in object 'schmuck'\n"));
 316         }
 317
 318       schmendrick_i s_schmendrick;
 319
 320       if (ACE_OS::strcmp (s_schmendrick._interface_repository_id (),
 321                           "IDL:floop_prefix/gleep/floop/schmendrick:524.23"))
 322         {
 323           ++error_count;
 324           ACE_ERROR ((LM_ERROR,
 325                       "pragma prefix error in object 'schmendrick'\n"));
 326         }
 327       if (ACE_OS::strcmp (gleep::floop::schmendrick::_desc_repository_id (),
 328                           "IDL:floop_prefix/gleep/floop/schmendrick:524.23"))
 329         {
 330           ++error_count;
 331           ACE_ERROR ((LM_ERROR,
 332                       "error in _desc_repository_id 'schmendrick'\n"));
 333         }
 334       if (ACE_OS::strcmp (gleep::floop::schmendrick::_desc_interface_name (),
 335                           "schmendrick"))
 336         {
 337           ++error_count;
 338           ACE_ERROR ((LM_ERROR,
 339                       "error in _desc_interface_name 'schmendrick'\n"));
 340         }
 341
 342       schlemazel_i s_schlemazel;
 343
 344       if (ACE_OS::strcmp (
 345               s_schlemazel._interface_repository_id (),
 346               "IDL:verklempt_prefix/gleep/floop/verklempt/schlemazel:1.0"
 347             ))
 348         {
 349           ++error_count;
 350           ACE_ERROR ((LM_ERROR,
 351                       "pragma prefix error in object 'schlemazel'\n"));
 352         }
 353
 354       schmegegging_i s_schmegegging;
 355
 356       if (ACE_OS::strcmp (s_schmegegging._interface_repository_id (),
 357                           "IDL:gleep_prefix/gleep/schmegegging:1.0"))
 358         {
 359           ++error_count;
 360           ACE_ERROR ((LM_ERROR,
 361                       "pragma prefix error in object 'schmegegging'\n"));
 362         }
 363
 364       {
 365         something_handler x;
 366         char const * base[] =
 367         {
 368           "IDL:bug_1985_c/d/AMI_somethingHandler:1.0",
 369           "IDL:bug_1985_a/b/AMI_somethingHandler:1.0",
 370           "IDL:omg.org/Messaging/ReplyHandler:1.0",
 371           "IDL:omg.org/CORBA/Object:1.0"
 372         };
 373
 374         for (size_t i = 0; i != sizeof (base)/sizeof (base[0]); ++i)
 375           {
 376             if (!x._is_a (base[i]))
 377               {
 378                 ++error_count;
 379                 ACE_ERROR ((LM_ERROR,
 380                            "something_handler::_is_a should return true for %C\n",
 381                            base[i]));
 382               }
 383           }
 384
 385         if (!dynamic_cast<POA_bug_1985_c::d::AMI_somethingHandler*> (&x))
 386           {
 387             ++error_count;
 388             ACE_ERROR ((LM_ERROR,
 389                        "mismatch in downcast for %C\n",
 390                         base[0]));
 391           }
 392
 393         if (!dynamic_cast<POA_bug_1985_a::b::AMI_somethingHandler*> (&x))
 394           {
 395             ++error_count;
 396             ACE_ERROR ((LM_ERROR,
 397                        "mismatch in downcast for %C\n",
 398                        base[1]));
 399           }
 400
 401         if (!dynamic_cast<POA_Messaging::ReplyHandler*> (&x))
 402           {
 403             ++error_count;
 404             ACE_ERROR ((LM_ERROR,
 405                        "mismatch in downcast for %C\n",
 406                        base[2]));
 407           }
 408       }
 409
 410       // Testing (de)marshaling of IDL union values
 411       // under duplicate and default case labels.
 412
 413       Field field;
 414       field.value.strValue (
 415           CORBA::string_dup ("duplicate case label test string"));
 416       field.value._d (FTYPE_VARCHAR);
 417       CORBA::Any any1;
 418       any1 <<= field;
 419       const Field *outfield = 0;
 420
 421       if ((any1 >>= outfield) == 0)
 422         {
 423           ++error_count;
 424           ACE_ERROR ((LM_ERROR,
 425                       "error in extraction of "
 426                       "duplicate case label value\n"));
 427         }
 428
 429       const char *str = outfield->value.strValue ();
 430
 431       if (ACE_OS::strcmp (str, "duplicate case label test string") != 0)
 432         {
 433           ++error_count;
 434           ACE_ERROR ((LM_ERROR,
 435                       "error - corruption of "
 436                       "duplicate case label value\n"));
 437         }
 438
 439       field.value.defstr (CORBA::string_dup ("default case test string"));
 440       any1 <<= field;
 441
 442       if ((any1 >>= outfield) == 0)
 443         {
 444           ++error_count;
 445           ACE_ERROR ((LM_ERROR,
 446                       "error in extraction of "
 447                       "default case label value\n"));
 448         }
 449
 450       str = outfield->value.defstr ();
 451
 452       if (ACE_OS::strcmp (str, "default case test string") != 0)
 453         {
 454           ++error_count;
 455           ACE_ERROR ((LM_ERROR,
 456                       "error - corruption of "
 457                       "default case label value\n"));
 458         }
 459
 460       if (SignedGen::val !=  -3)
 461         {
 462           ++error_count;
 463           ACE_ERROR ((LM_ERROR,
 464                       "error - signed integer literal "
 465                       "generated as unsigned\n"));
 466         }
 467
 468       root_poa->destroy (true, true);
 469     }
 470   catch (const CORBA::Exception& ex)
 471     {
 472       ex._tao_print_exception ("Unexpected exception in main");
 473       return 1;
 474     }
 475
 476   test_expressions (error_count);
 477
 478   return error_count ? 1 : 0;
 479 }