TAO/orbsvcs/tests/Property/client.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    client.cpp
   5  *
   6  *  Test client for the Property Service.
   7  *
   8  *  @author Alexander Babu Arulanthu <alex@cs.wustl.edu>
   9  */
  10 //=============================================================================
  11
  12
  13 #include "client.h"
  14 #include "tao/debug.h"
  15
  16
  17   Client::Client ()
  18 {
  19 }
  20
  21 int
  22 Client::init (int argc,
  23               ACE_TCHAR *argv[])
  24 {
  25   // Init the ORB.
  26   manager_.init (argc, argv);
  27   CORBA::ORB_var orb = manager_.orb();
  28   // Initialize the naming services
  29   if (my_name_client_.init (orb.in ()) != 0)
  30     ACE_ERROR_RETURN ((LM_ERROR,
  31                        " (%P|%t) Unable to initialize "
  32                        "the TAO_Naming_Client.\n"),
  33                       -1);
  34
  35   // Bind PropertySetDef Object.
  36
  37   CosNaming::Name propsetdef_name (1);
  38   propsetdef_name.length (1);
  39   propsetdef_name [0].id = CORBA::string_dup ("PropertySetDef");
  40   CORBA::Object_var propsetdef_obj = my_name_client_->resolve (propsetdef_name);
  41
  42   this->propsetdef_ = CosPropertyService::PropertySetDef::_narrow (propsetdef_obj.in ());
  43
  44   if (CORBA::is_nil (this->propsetdef_.in ()))
  45     ACE_ERROR_RETURN ((LM_ERROR,
  46                        "Could not resolve propsetdef in Naming server"),
  47                       -1);
  48
  49   return 0;
  50 }
  51
  52 // Testing the methods of the property service.
  53
  54 int
  55 Client::property_tester ()
  56 {
  57   // = Testing PropertySet & Iterators.
  58
  59   // Testing define_property () of PropertySet interface.
  60   this->test_define_property ();
  61
  62   // Test the number of properties.
  63   this->test_get_number_of_properties ();
  64
  65   // Testing get_all_property_names.
  66   this->test_get_all_property_names ();
  67
  68   // Test get_property_value.
  69   this->test_get_property_value ();
  70
  71   // Testing delete property.
  72   this->test_delete_property ("no_property");
  73
  74   // Testing get_properties.
  75   this->test_get_properties ();
  76
  77   // Testing delete_properties.
  78   this->test_delete_properties ();
  79
  80   // Test the number of properties.
  81   this->test_get_number_of_properties ();
  82
  83   // Testing define_properties.
  84   this->test_define_properties ();
  85
  86   // Test the number of properties.
  87   this->test_get_number_of_properties ();
  88
  89   // Testing get_all_property_names.
  90   this->test_get_all_property_names ();
  91
  92   // Testing get_all_properties.
  93   this->test_get_all_properties ();
  94
  95   // = Testing PropertySetDef & Iterators.
  96
  97   // Testing define_property_with_mode.
  98   this->test_define_property_with_mode ();
  99
 100   return 0;
 101 }
 102
 103 // Testing define_property.
 104
 105 int
 106 Client::test_define_property ()
 107 {
 108   CORBA::Any anyval;
 109
 110   // Prepare a char and "define" that in the PropertySet.
 111   CORBA::Char ch = '#';
 112   anyval <<= CORBA::Any::from_char (ch);
 113   ch = '*';
 114   anyval >>= CORBA::Any::to_char (ch);
 115
 116   this->propsetdef_->define_property ("char_property",
 117                                       anyval);
 118
 119   // Prepare a Short and "define" that in the PropertySet.
 120   CORBA::Short s = 3;
 121   anyval <<= s;
 122   s = 7;
 123   anyval >>= s;
 124
 125   propsetdef_->define_property ("short_property",
 126                                 anyval);
 127
 128   // Prepare a Long and "define" that in the PropertySet.
 129   CORBA::Long l = 931232;
 130   anyval <<= l;
 131   l = 931233;
 132   anyval >>= l;
 133   CORBA::Any newany(anyval);
 134   propsetdef_->define_property ("long_property",
 135                                 anyval);
 136
 137   // Prepare a Float and "define" that in the PropertySet.
 138   CORBA::Float f = 3.14F;
 139   anyval <<= f;
 140   f = 4.14F;
 141   anyval >>= f;
 142
 143   propsetdef_->define_property ("float_property",
 144                                 anyval);
 145
 146
 147   // Prepare a String and "define" that in the PropertySet.
 148   CORBA::String_var strvar (CORBA::string_dup ("Test_String"));
 149   anyval <<= strvar.in ();
 150   const char * newstr;
 151   anyval >>= newstr;
 152   propsetdef_->define_property ("string_property",
 153                                 anyval);
 154
 155
 156   return 0;
 157 }
 158
 159 // Testing get_all_property_names of the PropertySet.
 160
 161 int
 162 Client::test_get_all_property_names ()
 163 {
 164   // Get the size.
 165   CORBA::ULong num_of_properties =
 166     propsetdef_->get_number_of_properties ();
 167
 168   // Get half on the names and half of on the iterator.
 169   CORBA::ULong how_many = num_of_properties / 2;
 170
 171   // The extra ptr's and out's required to avoind SunnCC's warning
 172   // when foo.out () is passed to a function.
 173   CosPropertyService::PropertyNames_var names_var;
 174   CosPropertyService::PropertyNames     *names_ptr = 0;
 175   CosPropertyService::PropertyNames_out names_out (names_ptr);
 176
 177   CosPropertyService::PropertyNamesIterator_var iterator_var;
 178   CosPropertyService::PropertyNamesIterator_ptr iterator_ptr;
 179   CosPropertyService::PropertyNamesIterator_out iterator_out (iterator_ptr);
 180
 181   propsetdef_->get_all_property_names (how_many,
 182                                        names_out,
 183                                        iterator_out);
 184
 185   // Get the values back to var.
 186   names_var = names_out.ptr ();
 187   iterator_var = iterator_out.ptr ();
 188
 189   // Print out the names in the names-sequence.
 190   if (TAO_debug_level > 0)
 191     {
 192       if (names_var.ptr () != 0)
 193         {
 194           CORBA::ULong len = names_var->length ();
 195
 196           for (CORBA::ULong ni = 0; ni < len; ni++)
 197             ACE_DEBUG ((LM_DEBUG,
 198                         "%s\n",
 199                         (const char *) names_var [ni]));
 200         }
 201
 202       // Iterate thru and print out the names in the iterator, if any.
 203       if (iterator_var.ptr () != 0)
 204         {
 205           // Helper variables to stop the SunCC warnings on on foo.out
 206           // ().
 207           CosPropertyService::PropertyName  name_ptr = 0;
 208           CosPropertyService::PropertyName_out name_out (name_ptr);
 209
 210           // Call the function.
 211           CORBA::Boolean next_one_result = iterator_var->next_one (name_out);
 212
 213           // Get the values back on a _var variable.
 214           CosPropertyService::PropertyName_var name_var = name_out.ptr ();
 215
 216           while (next_one_result == 1)
 217             {
 218               ACE_DEBUG ((LM_DEBUG, "%s\n", name_var.in ()));
 219
 220               // Call the function to iterate again.
 221               next_one_result = iterator_var->next_one (name_out);
 222
 223               // Get the values back on a _var variable.
 224               name_var = name_out.ptr ();
 225             }
 226
 227         }
 228     }
 229   return 0;
 230 }
 231
 232 // Test get_properties. Give a sequence of names and get all their
 233 // properties.
 234
 235 int
 236 Client::test_get_properties ()
 237 {
 238   // Get float_property, string_property and no_property. If return
 239   // value is false and type is tc_void then that name is not there in
 240   // the PropertySet.
 241   CosPropertyService::PropertyNames_var names;
 242   CosPropertyService::PropertyNames     *names_ptr;
 243
 244   ACE_NEW_RETURN (names_ptr,
 245                   CosPropertyService::PropertyNames,
 246                   -1);
 247   names = names_ptr;
 248
 249   names->length (3);
 250   names [0u] = CORBA::string_dup ("float_property");
 251   //names [1] = CORBA::string_dup ("string_property");
 252   names [1u] = CORBA::string_dup ("long_property");
 253   names [2u] = CORBA::string_dup ("char_property");
 254   //names [2] = CORBA::string_dup ("no_property");
 255
 256
 257   CosPropertyService::Properties *properties_ptr = 0;
 258   CosPropertyService::Properties_out properties_out (properties_ptr);
 259
 260   // Get the properties.
 261   CORBA::Boolean return_val = propsetdef_->get_properties (names.in (),
 262                                                            properties_out);
 263   ACE_UNUSED_ARG (return_val);
 264
 265   // Get the value to the _var.
 266   CosPropertyService::Properties_var properties = properties_out.ptr ();
 267
 268   if (TAO_debug_level > 0)
 269     {
 270       if (properties.ptr () != 0)
 271         {
 272           // Go thru the properties and print them out, if they are not
 273           // _tc_void typed values.
 274           CORBA::ULong len = properties->length ();
 275
 276           for (CORBA::ULong pi = 0; pi < len; pi++)
 277             {
 278               // Print the name.
 279               ACE_DEBUG ((LM_DEBUG,
 280                           "%s : ",
 281                           (const char *) properties [pi].property_name.in ()));
 282
 283               // Print the value.
 284               CORBA::Char    char_val;
 285               CORBA::Long    long_val;
 286               CORBA::ULong  ulong_val;
 287               CORBA::Float  float_val;
 288               CORBA::Double double_val;
 289               const char *  string_val;
 290
 291               if (properties [pi].property_value >>=
 292                   CORBA::Any::to_char (char_val))
 293                 {
 294                   ACE_DEBUG ((LM_DEBUG, "%c\n", char_val));
 295                 }
 296               else if (properties [pi].property_value >>= long_val)
 297                 {
 298                   ACE_DEBUG ((LM_DEBUG, "%d\n", long_val));
 299                 }
 300               else if (properties [pi].property_value >>= ulong_val)
 301                 {
 302                   ACE_DEBUG ((LM_DEBUG, "%ld\n", ulong_val));
 303                 }
 304               else if (properties [pi].property_value >>= float_val)
 305                 {
 306                   ACE_DEBUG ((LM_DEBUG, "%f\n", long_val));
 307                 }
 308               else if (properties [pi].property_value >>= double_val)
 309                 {
 310                   ACE_DEBUG ((LM_DEBUG, "%f\n", double_val));
 311                 }
 312               else if (properties [pi].property_value >>= string_val)
 313                 {
 314                   ACE_DEBUG ((LM_DEBUG, "%s\n", string_val));
 315                 }
 316             }
 317         }
 318     }
 319   return 0;
 320 }
 321
 322 // Testing, get_number_of_properties.
 323
 324 int
 325 Client::test_get_number_of_properties ()
 326 {
 327   CORBA::ULong nproperties = this->propsetdef_->get_number_of_properties ();
 328
 329   if (TAO_debug_level > 0)
 330     {
 331       ACE_DEBUG ((LM_DEBUG,
 332                   "\nNumber of props : %d\n",
 333                   nproperties));
 334     }
 335   return 0;
 336 }
 337
 338 // Test delete_property.
 339
 340 int
 341 Client::test_delete_property (const char *property_name)
 342 {
 343   try
 344     {
 345       CORBA::String_var property_name_var (property_name);
 346
 347       this->propsetdef_->delete_property (property_name_var.in ());
 348     }
 349   catch (const CORBA::UserException&)
 350     {
 351       // For no property, it is ok to get the user exception.
 352       return 0;
 353     }
 354   catch (const CORBA::Exception& ex)
 355     {
 356       ex._tao_print_exception ("Not an user exception");
 357       return -1;
 358     }
 359
 360   return 0;
 361 }
 362
 363 // Test delete_properties.
 364 // Make a sequence of property names and delete them from the
 365 // PropertySet.  Deleting char, short, long, float and string
 366 // properties.
 367
 368 int
 369 Client::test_delete_properties ()
 370 {
 371   CosPropertyService::PropertyNames prop_names;
 372   prop_names.length (3);
 373   prop_names [0] = CORBA::string_dup ("char_property");
 374   prop_names [1] = CORBA::string_dup ("short_property");
 375   prop_names [2] = CORBA::string_dup ("long_property");
 376   // prop_names [3] = CORBA::string_dup ("no_property");
 377   this->propsetdef_->delete_properties (prop_names);
 378
 379   return 0;
 380 }
 381
 382 // Defines a sequnce of properties containing, char, short, long,
 383 // float in the property set.
 384
 385 int
 386 Client::test_define_properties ()
 387 {
 388   CosPropertyService::Properties nproperties;
 389   nproperties.length (4);
 390   CORBA::Any anyval;
 391   // Prepare a char and "define" that in the PropertySet.
 392   CORBA::Char ch = '#';
 393   anyval <<= CORBA::Any::from_char (ch);
 394   ch = '*';
 395   anyval >>= CORBA::Any::to_char (ch);
 396   nproperties[0].property_name  = CORBA::string_dup ("char_property");
 397   nproperties[0].property_value <<= CORBA::Any::from_char (ch);
 398
 399   // Prepare a Short and "define" that in the PropertySet.
 400   CORBA::Short s = 3;
 401   anyval <<= s;
 402   s = 7;
 403   anyval >>= s;
 404   nproperties[1].property_name  = CORBA::string_dup ("short_property");
 405   nproperties[1].property_value <<= s;
 406
 407   // Prepare a Long and "define" that in the PropertySet.
 408   CORBA::Long l = 931232;
 409   anyval <<= l;
 410   l = 931233;
 411   anyval >>= l;
 412   nproperties[2].property_name  = CORBA::string_dup ("long_property");
 413   nproperties[2].property_value <<= l;
 414
 415   // Prepare a Float and "define" that in the PropertySet.
 416   CORBA::Float f = 3.14F;
 417   anyval <<= f;
 418   f = 4.14F;
 419   anyval >>= f;
 420   nproperties[3].property_name  = CORBA::string_dup ("float_property");
 421   nproperties[3].property_value <<= f;
 422
 423   // Define this sequence of properties now.
 424   this->propsetdef_->define_properties (nproperties);
 425
 426   return 0;
 427 }
 428
 429 // Test get_all_properties.
 430
 431 int
 432 Client::test_get_all_properties ()
 433 {
 434   // Get the number of current properties.
 435   CORBA::ULong num_of_properties =
 436     this->propsetdef_->get_number_of_properties ();
 437   ACE_UNUSED_ARG (num_of_properties);
 438
 439   // Get half on the properties and half of on the iterator.
 440   CORBA::ULong how_many = 1;
 441
 442   // Helper variables to avoid SunCC warnings.
 443   CosPropertyService::Properties *properties_ptr = 0;
 444   CosPropertyService::Properties_out properties_out (properties_ptr);
 445   CosPropertyService::PropertiesIterator_ptr iterator_ptr = 0;
 446   CosPropertyService::PropertiesIterator_out iterator_out (iterator_ptr);
 447
 448   propsetdef_->get_all_properties (how_many,
 449                                    properties_out,
 450                                    iterator_out);
 451
 452   // Get these values to the _var's.
 453   CosPropertyService::Properties_var properties = properties_out.ptr ();
 454   CosPropertyService::PropertiesIterator_var iterator = iterator_out.ptr ();
 455
 456   // Print out the properties now.
 457   if (TAO_debug_level > 0)
 458     {
 459       if (properties.ptr () != 0)
 460         {
 461           CORBA::ULong len = properties->length ();
 462
 463           for (CORBA::ULong pi = 0; pi < len; pi++)
 464             {
 465               // Print the property_name.
 466               ACE_DEBUG ((LM_DEBUG,
 467                           "%s : ",
 468                           properties [pi].property_name.in ()));
 469
 470               // Print the value if type is not tk_void.
 471               if (properties [pi].property_value.type () == CORBA::_tc_void)
 472                 ACE_DEBUG ((LM_DEBUG,"Void\n"));
 473
 474               if (properties [pi].property_value.type () == CORBA::_tc_float)
 475                 {
 476                   CORBA::Float f;
 477                   properties [pi].property_value >>= f;
 478                   ACE_DEBUG ((LM_DEBUG,"%f\n", f));
 479                 }
 480
 481               if (properties [pi].property_value.type () == CORBA::_tc_string)
 482                 {
 483                   const char* str;
 484                   properties [pi].property_value >>= str;
 485                   ACE_DEBUG ((LM_DEBUG,"%s\n", str));
 486                 }
 487
 488               if (properties [pi].property_value.type () == CORBA::_tc_long)
 489                 {
 490                   CORBA::Long l;
 491                   properties [pi].property_value >>= l;
 492                   ACE_DEBUG ((LM_DEBUG,"%d\n", l));
 493                 }
 494             }
 495         }
 496
 497       // Pass thru the iterator.
 498       if (iterator.ptr () != 0)
 499         {
 500           // Helper variables to avoid warnings with .out () in SunCC.
 501           CosPropertyService::Property* property_ptr = 0;
 502           CosPropertyService::Property_out property_out (property_ptr);
 503
 504           // Call the function.
 505           CORBA::Boolean next_one_result = iterator->next_one (property_out);
 506
 507           // Get the value to the _var variable.
 508           CosPropertyService::Property_var property = property_out.ptr ();
 509
 510           while (next_one_result != 0)
 511             {
 512               ACE_DEBUG ((LM_DEBUG,
 513                           "%s : ",
 514                           property->property_name.in ()));
 515
 516               // Print the property_value.
 517               if (property->property_value.type () == CORBA::_tc_char)
 518                 {
 519                   CORBA::Char c;
 520                   property->property_value >>= CORBA::Any::to_char (c);
 521                   ACE_DEBUG ((LM_DEBUG,"%c\n", c));
 522                 }
 523
 524               if (property->property_value.type () == CORBA::_tc_short)
 525                 {
 526                   CORBA::Short s;
 527                   property->property_value >>= s;
 528                   ACE_DEBUG ((LM_DEBUG,"%d\n", s));
 529                 }
 530
 531               if (property->property_value.type () == CORBA::_tc_float)
 532                 {
 533                   CORBA::Float f;
 534                   property->property_value >>= f;
 535                   ACE_DEBUG ((LM_DEBUG,"%f\n", f));
 536                 }
 537
 538               if (property->property_value.type () == CORBA::_tc_string)
 539                 {
 540                   const char* str;
 541                   property->property_value >>= str;
 542                   ACE_DEBUG ((LM_DEBUG,"%s\n", str));
 543                 }
 544
 545               if (property->property_value.type () == CORBA::_tc_long)
 546                 {
 547                   CORBA::Long l;
 548                   property->property_value >>= l;
 549                   ACE_DEBUG ((LM_DEBUG,"%d\n", l));
 550                 }
 551
 552               // Call the function for the next iteraton.
 553               next_one_result = iterator->next_one (property_out);
 554
 555               // Get the value to the _var variable.
 556               property = property_out.ptr ();
 557             }
 558         }
 559     }
 560   return 0;
 561 }
 562
 563 // Testing define property with mode.
 564 // Defines char, short, long and float properties with different modes.
 565 int
 566 Client::test_define_property_with_mode ()
 567 {
 568   CORBA::Any anyval;
 569
 570   // Prepare a char and "define" that in the PropertySet.
 571   CORBA::Char ch = '#';
 572   anyval <<= CORBA::Any::from_char (ch);
 573   ch = '*';
 574   anyval >>= CORBA::Any::to_char (ch);
 575
 576   this->propsetdef_->define_property_with_mode ("char_property",
 577                                                 anyval,
 578                                                 CosPropertyService::normal);
 579
 580   // Prepare a Short and "define" that in the PropertySet.
 581   CORBA::Short s = 3;
 582   anyval <<= s;
 583   s = 7;
 584   anyval >>= s;
 585
 586   propsetdef_->define_property_with_mode ("short_property",
 587                                           anyval,
 588                                           CosPropertyService::read_only);
 589
 590   // Prepare a Long and "define" that in the PropertySet.
 591   CORBA::Long l = 931232;
 592   anyval <<= l;
 593   l = 931233;
 594   anyval >>= l;
 595   CORBA::Any newany(anyval);
 596   propsetdef_->define_property_with_mode ("long_property",
 597                                           anyval,
 598                                           CosPropertyService::fixed_normal);
 599
 600
 601   // Prepare a Float and "define" that in the PropertySet.
 602   CORBA::Float f = 3.14F;
 603   anyval <<= f;
 604   f = 4.14F;
 605   anyval >>= f;
 606   propsetdef_->define_property_with_mode ("float_property",
 607                                           anyval,
 608                                           CosPropertyService::fixed_readonly);
 609
 610   // Prepare a String and "define" that in the PropertySet.
 611   CORBA::String_var strvar (CORBA::string_dup ("Test_String"));
 612   anyval <<= strvar.in ();
 613   const char* newstr;
 614   anyval >>= newstr;
 615
 616   propsetdef_->define_property  ("string_property",
 617                                  anyval);
 618
 619   return 0;
 620 }
 621
 622 int
 623 Client::test_get_property_value ()
 624 {
 625   try
 626     {
 627       // Get the ior property.
 628       CORBA::Any_var any_ptr = this->propsetdef_->get_property_value ("PropertySetDef_IOR");
 629
 630       // Check whether the IOR is fine.
 631       CORBA::Object_var propsetdef_object;
 632       (*any_ptr) >>= CORBA::Any::to_object (propsetdef_object.out ());
 633
 634       CosPropertyService::PropertySetDef_var propsetdef =
 635         CosPropertyService::PropertySetDef::_narrow (propsetdef_object.in ());
 636
 637       if (CORBA::is_nil (propsetdef.in ()))
 638         ACE_ERROR_RETURN ((LM_ERROR,
 639                            "invalid object reference\n"),
 640                           -1);
 641     }
 642   catch (const CORBA::Exception& ex)
 643     {
 644       ex._tao_print_exception ("get_property_value");
 645       return -1;
 646     }
 647   return 0;
 648 }
 649
 650 int
 651 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 652 {
 653   try
 654     {
 655       Client client;
 656
 657       if (client.init (argc, argv) == -1)
 658         return 1;
 659
 660       //  client.run ();
 661       int ret = client.property_tester ();
 662       if (ret != 0)
 663         ACE_DEBUG ((LM_DEBUG, "Test failed\n"));
 664       else
 665         ACE_DEBUG ((LM_DEBUG, "Test succeeded\n"));
 666     }
 667   catch (const CORBA::Exception& ex)
 668     {
 669       ex._tao_print_exception ("PropertyService Test : client");
 670       return -1;
 671     }
 672
 673   return 0;
 674 }