diff options
Diffstat (limited to 'TAO/orbsvcs/tests/Property/client.cpp')
| -rw-r--r-- | TAO/orbsvcs/tests/Property/client.cpp | 763 |
1 files changed, 763 insertions, 0 deletions
diff --git a/TAO/orbsvcs/tests/Property/client.cpp b/TAO/orbsvcs/tests/Property/client.cpp new file mode 100644 index 00000000000..bfc5efa2dd0 --- /dev/null +++ b/TAO/orbsvcs/tests/Property/client.cpp @@ -0,0 +1,763 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/orbsvcs/tests/Property +// +// = FILENAME +// client.cpp +// +// = DESCRIPTION +// Test client for the Property Service. +// +// = AUTHORS +// Alexander Babu Arulanthu <alex@cs.wustl.edu> +// +// ============================================================================ + +#include "client.h" +#include "tao/debug.h" + +ACE_RCSID(CosPropertyService, client, "$Id$") + + Client::Client (void) +{ +} + +int +Client::init (int argc, + char *argv[] + ACE_ENV_ARG_DECL) +{ + // Init the ORB. + manager_.init (argc, + argv + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Initialize the naming services + if (my_name_client_.init (manager_.orb()) != 0) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Unable to initialize " + "the TAO_Naming_Client. \n"), + -1); + + // Bind PropertySetDef Object. + + CosNaming::Name propsetdef_name (1); + propsetdef_name.length (1); + propsetdef_name [0].id = CORBA::string_dup ("PropertySetDef"); + CORBA::Object_var propsetdef_obj = my_name_client_->resolve (propsetdef_name + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + this->propsetdef_ = CosPropertyService::PropertySetDef::_narrow (propsetdef_obj.in () + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + if (CORBA::is_nil (this->propsetdef_.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + "Could not resolve propsetdef in Naming server"), + -1); + + return 0; +} + +// Testing the methods of the property service. + +int +Client::property_tester (ACE_ENV_SINGLE_ARG_DECL) +{ + // = Testing PropertySet & Iterators. + + // Testing define_property () of PropertySet interface. + this->test_define_property (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Test the number of properties. + this->test_get_number_of_properties (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Testing get_all_property_names. + this->test_get_all_property_names (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Test get_property_value. + this->test_get_property_value (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Testing delete property. + this->test_delete_property ("no_property" ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Testing get_properties. + this->test_get_properties (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Testing delete_properties. + this->test_delete_properties (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Test the number of properties. + this->test_get_number_of_properties (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Testing define_properties. + this->test_define_properties (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Test the number of properties. + this->test_get_number_of_properties (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Testing get_all_property_names. + this->test_get_all_property_names (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Testing get_all_properties. + this->test_get_all_properties (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // = Testing PropertySetDef & Iterators. + + // Testing define_property_with_mode. + this->test_define_property_with_mode (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + return 0; +} + +// Testing define_property. + +int +Client::test_define_property (ACE_ENV_SINGLE_ARG_DECL) +{ + CORBA::Any anyval; + + // Prepare a char and "define" that in the PropertySet. + CORBA::Char ch = '#'; + anyval <<= CORBA::Any::from_char (ch); + ch = '*'; + anyval >>= CORBA::Any::to_char (ch); + + this->propsetdef_->define_property ("char_property", + anyval + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Prepare a Short and "define" that in the PropertySet. + CORBA::Short s = 3; + anyval <<= s; + s = 7; + anyval >>= s; + + propsetdef_->define_property ("short_property", + anyval + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Prepare a Long and "define" that in the PropertySet. + CORBA::Long l = 931232; + anyval <<= l; + l = 931233; + anyval >>= l; + CORBA::Any newany(anyval); + propsetdef_->define_property ("long_property", + anyval + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Prepare a Float and "define" that in the PropertySet. + CORBA::Float f = 3.14F; + anyval <<= f; + f = 4.14F; + anyval >>= f; + + propsetdef_->define_property ("float_property", + anyval + ACE_ENV_ARG_PARAMETER); + + ACE_CHECK_RETURN (-1); + + // Prepare a String and "define" that in the PropertySet. + CORBA::String_var strvar (CORBA::string_dup ("Test_String")); + anyval <<= strvar.in (); + const char * newstr; + anyval >>= newstr; + propsetdef_->define_property ("string_property", + anyval + ACE_ENV_ARG_PARAMETER); + + ACE_CHECK_RETURN (-1); + + return 0; +} + +// Testing get_all_property_names of the PropertySet. + +int +Client::test_get_all_property_names (ACE_ENV_SINGLE_ARG_DECL) +{ + // Get the size. + CORBA::ULong num_of_properties = + propsetdef_->get_number_of_properties (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Get half on the names and half of on the iterator. + CORBA::ULong how_many = num_of_properties / 2; + + // The extra ptr's and out's required to avoind SunnCC's warning + // when foo.out () is passed to a funtion. + CosPropertyService::PropertyNames_var names_var; + CosPropertyService::PropertyNames *names_ptr = 0; + CosPropertyService::PropertyNames_out names_out (names_ptr); + + CosPropertyService::PropertyNamesIterator_var iterator_var; + CosPropertyService::PropertyNamesIterator_ptr iterator_ptr; + CosPropertyService::PropertyNamesIterator_out iterator_out (iterator_ptr); + + propsetdef_->get_all_property_names (how_many, + names_out, + iterator_out + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Get the values back to var. + names_var = names_out.ptr (); + iterator_var = iterator_out.ptr (); + + // Print out the names in the names-sequence. + if (TAO_debug_level > 0) + { + if (names_var.ptr () != 0) + { + CORBA::ULong len = names_var->length (); + + for (CORBA::ULong ni = 0; ni < len; ni++) + ACE_DEBUG ((LM_DEBUG, + "%s\n", + (const char *) names_var [ni])); + } + + // Iterate thru and print out the names in the iterator, if any. + if (iterator_var.ptr () != 0) + { + // Helper variables to stop the SunCC warnings on on foo.out + // (). + CosPropertyService::PropertyName name_ptr = 0; + CosPropertyService::PropertyName_out name_out (name_ptr); + + // Call the function. + CORBA::Boolean next_one_result = iterator_var->next_one (name_out ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Get the values back on a _var variable. + CosPropertyService::PropertyName_var name_var = name_out.ptr (); + + while (next_one_result == 1) + { + ACE_DEBUG ((LM_DEBUG, "%s\n", name_var.in ())); + + // Call the function to iterate again. + next_one_result = iterator_var->next_one (name_out ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Get the values back on a _var variable. + name_var = name_out.ptr (); + } + + ACE_CHECK_RETURN (-1); + } + } + return 0; +} + +// Test get_properties. Give a sequence of names and get all their +// properties. + +int +Client::test_get_properties (ACE_ENV_SINGLE_ARG_DECL) +{ + // Get float_property, string_property and no_property. If return + // value is false and type is tc_void then that name is not there in + // the PropertySet. + CosPropertyService::PropertyNames_var names; + CosPropertyService::PropertyNames *names_ptr; + + ACE_NEW_RETURN (names_ptr, + CosPropertyService::PropertyNames, + -1); + names = names_ptr; + + names->length (3); + names [0u] = CORBA::string_dup ("float_property"); + //names [1] = CORBA::string_dup ("string_property"); + names [1u] = CORBA::string_dup ("long_property"); + names [2u] = CORBA::string_dup ("char_property"); + //names [2] = CORBA::string_dup ("no_property"); + + + CosPropertyService::Properties *properties_ptr = 0; + CosPropertyService::Properties_out properties_out (properties_ptr); + + // Get the properties. + CORBA::Boolean return_val = propsetdef_->get_properties (names.in (), + properties_out + ACE_ENV_ARG_PARAMETER); + ACE_UNUSED_ARG (return_val); + ACE_CHECK_RETURN (-1); + + + if (TAO_debug_level > 0) + { + // Get the value to the _var. + CosPropertyService::Properties_var properties = properties_out.ptr (); + + if (properties.ptr () != 0) + { + // Go thru the properties and print them out, if they are not + // _tc_void typed values. + CORBA::ULong len = properties->length (); + + for (CORBA::ULong pi = 0; pi < len; pi++) + { + // Print the name. + ACE_DEBUG ((LM_DEBUG, + "%s : ", + (const char *) properties [pi].property_name.in ())); + + // Print the value. + CORBA::Char char_val; + CORBA::Long long_val; + CORBA::ULong ulong_val; + CORBA::Float float_val; + CORBA::Double double_val; + const char * string_val; + + if (properties [pi].property_value >>= + CORBA::Any::to_char (char_val)) + { + ACE_DEBUG ((LM_DEBUG, "%c\n", char_val)); + } + else if (properties [pi].property_value >>= long_val) + { + ACE_DEBUG ((LM_DEBUG, "%d\n", long_val)); + } + else if (properties [pi].property_value >>= ulong_val) + { + ACE_DEBUG ((LM_DEBUG, "%ld\n", ulong_val)); + } + else if (properties [pi].property_value >>= float_val) + { + ACE_DEBUG ((LM_DEBUG, "%f\n", long_val)); + } + else if (properties [pi].property_value >>= double_val) + { + ACE_DEBUG ((LM_DEBUG, "%f\n", double_val)); + } + else if (properties [pi].property_value >>= string_val) + { + ACE_DEBUG ((LM_DEBUG, "%s\n", string_val)); + } + } + } + } + return 0; +} + +// Testing, get_number_of_properties. + +int +Client::test_get_number_of_properties (ACE_ENV_SINGLE_ARG_DECL) +{ + CORBA::ULong nproperties = this->propsetdef_->get_number_of_properties (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + if (TAO_debug_level > 0) + { + ACE_DEBUG ((LM_DEBUG, + "\nNumber of props : %d\n", + nproperties)); + } + return 0; +} + +// Test delete_property. + +int +Client::test_delete_property (const char *property_name + ACE_ENV_ARG_DECL) +{ + ACE_TRY + { + CORBA::String_var property_name_var (property_name); + + this->propsetdef_->delete_property (property_name_var.in () + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCH (CORBA::UserException, ex) + { + // For no property, it is ok to get the user exception. + return 0; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ex, "Not an user exception"); + return -1; + } + ACE_ENDTRY; + ACE_CHECK_RETURN (-1); + + return 0; +} + +// Test delete_properties. +// Make a sequence of property names and delete them from the +// PropertySet. Deleting char, short, long, float and string +// properties. + +int +Client::test_delete_properties (ACE_ENV_SINGLE_ARG_DECL) +{ + CosPropertyService::PropertyNames prop_names; + prop_names.length (3); + prop_names [0] = CORBA::string_dup ("char_property"); + prop_names [1] = CORBA::string_dup ("short_property"); + prop_names [2] = CORBA::string_dup ("long_property"); + // prop_names [3] = CORBA::string_dup ("no_property"); + this->propsetdef_->delete_properties (prop_names + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN ( 0); + + return 0; +} + +// Defines a sequnce of properties containing, char, short, long, +// float in the property set. + +int +Client::test_define_properties (ACE_ENV_SINGLE_ARG_DECL) +{ + CosPropertyService::Properties nproperties; + nproperties.length (4); + CORBA::Any anyval; + // Prepare a char and "define" that in the PropertySet. + CORBA::Char ch = '#'; + anyval <<= CORBA::Any::from_char (ch); + ch = '*'; + anyval >>= CORBA::Any::to_char (ch); + nproperties[0].property_name = CORBA::string_dup ("char_property"); + nproperties[0].property_value <<= CORBA::Any::from_char (ch); + + // Prepare a Short and "define" that in the PropertySet. + CORBA::Short s = 3; + anyval <<= s; + s = 7; + anyval >>= s; + nproperties[1].property_name = CORBA::string_dup ("short_property"); + nproperties[1].property_value <<= s; + + // Prepare a Long and "define" that in the PropertySet. + CORBA::Long l = 931232; + anyval <<= l; + l = 931233; + anyval >>= l; + nproperties[2].property_name = CORBA::string_dup ("long_property"); + nproperties[2].property_value <<= l; + + // Prepare a Float and "define" that in the PropertySet. + CORBA::Float f = 3.14F; + anyval <<= f; + f = 4.14F; + anyval >>= f; + nproperties[3].property_name = CORBA::string_dup ("float_property"); + nproperties[3].property_value <<= f; + + // Define this sequence of properties now. + this->propsetdef_->define_properties (nproperties ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN ( -1); + + return 0; +} + +// Test get_all_properties. + +int +Client::test_get_all_properties (ACE_ENV_SINGLE_ARG_DECL) +{ + // Get the number of current properties. + CORBA::ULong num_of_properties = + this->propsetdef_->get_number_of_properties (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_CHECK_RETURN ( -1); + ACE_UNUSED_ARG (num_of_properties); + + // Get half on the properties and half of on the iterator. + CORBA::ULong how_many = 1; + + // Helper variables to avoid SunCC warnings. + CosPropertyService::Properties *properties_ptr = 0; + CosPropertyService::Properties_out properties_out (properties_ptr); + CosPropertyService::PropertiesIterator_ptr iterator_ptr = 0; + CosPropertyService::PropertiesIterator_out iterator_out (iterator_ptr); + + propsetdef_->get_all_properties (how_many, + properties_out, + iterator_out + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN ( -1); + + // Get these values to the _var's. + CosPropertyService::Properties_var properties = properties_out.ptr (); + CosPropertyService::PropertiesIterator_var iterator = iterator_out.ptr (); + + // Print out the properties now. + if (TAO_debug_level > 0) + { + if (properties.ptr () != 0) + { + CORBA::ULong len = properties->length (); + + for (CORBA::ULong pi = 0; pi < len; pi++) + { + // Print the property_name. + ACE_DEBUG ((LM_DEBUG, + "%s : ", + properties [pi].property_name.in ())); + + // Print the value if type is not tk_void. + if (properties [pi].property_value.type () == CORBA::_tc_void) + ACE_DEBUG ((LM_DEBUG,"Void\n")); + + if (properties [pi].property_value.type () == CORBA::_tc_float) + { + CORBA::Float f; + properties [pi].property_value >>= f; + ACE_DEBUG ((LM_DEBUG,"%f\n", f)); + } + + if (properties [pi].property_value.type () == CORBA::_tc_string) + { + const char* str; + properties [pi].property_value >>= str; + ACE_DEBUG ((LM_DEBUG,"%s\n", str)); + } + + if (properties [pi].property_value.type () == CORBA::_tc_long) + { + CORBA::Long l; + properties [pi].property_value >>= l; + ACE_DEBUG ((LM_DEBUG,"%d\n", l)); + } + } + } + + // Pass thru the iterator. + if (iterator.ptr () != 0) + { + // Helper variables to avoid warnings with .out () in SunCC. + CosPropertyService::Property* property_ptr = 0; + CosPropertyService::Property_out property_out (property_ptr); + + // Call the funtion. + CORBA::Boolean next_one_result = iterator->next_one (property_out + ACE_ENV_ARG_PARAMETER); + + // Get the value to the _var variable. + CosPropertyService::Property_var property = property_out.ptr (); + + while (next_one_result != 0) + { + ACE_CHECK_RETURN ( -1); + ACE_DEBUG ((LM_DEBUG, + "%s : ", + property->property_name.in ())); + + // Print the property_value. + if (property->property_value.type () == CORBA::_tc_char) + { + CORBA::Char c; + property->property_value >>= CORBA::Any::to_char (c); + ACE_DEBUG ((LM_DEBUG,"%c\n", c)); + } + + if (property->property_value.type () == CORBA::_tc_short) + { + CORBA::Short s; + property->property_value >>= s; + ACE_DEBUG ((LM_DEBUG,"%d\n", s)); + } + + if (property->property_value.type () == CORBA::_tc_float) + { + CORBA::Float f; + property->property_value >>= f; + ACE_DEBUG ((LM_DEBUG,"%f\n", f)); + } + + if (property->property_value.type () == CORBA::_tc_string) + { + const char* str; + property->property_value >>= str; + ACE_DEBUG ((LM_DEBUG,"%s\n", str)); + } + + if (property->property_value.type () == CORBA::_tc_long) + { + CORBA::Long l; + property->property_value >>= l; + ACE_DEBUG ((LM_DEBUG,"%d\n", l)); + } + + // Call the function for the next iteraton. + next_one_result = iterator->next_one (property_out + ACE_ENV_ARG_PARAMETER); + + // Get the value to the _var variable. + property = property_out.ptr (); + } + ACE_CHECK_RETURN ( -1); + } + } + return 0; +} + +// Testing define property with mode. +// Defines char, short, long and float properties with different modes. +int +Client::test_define_property_with_mode (ACE_ENV_SINGLE_ARG_DECL) +{ + CORBA::Any anyval; + + // Prepare a char and "define" that in the PropertySet. + CORBA::Char ch = '#'; + anyval <<= CORBA::Any::from_char (ch); + ch = '*'; + anyval >>= CORBA::Any::to_char (ch); + + this->propsetdef_->define_property_with_mode ("char_property", + anyval, + CosPropertyService::normal + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Prepare a Short and "define" that in the PropertySet. + CORBA::Short s = 3; + anyval <<= s; + s = 7; + anyval >>= s; + + propsetdef_->define_property_with_mode ("short_property", + anyval, + CosPropertyService::read_only + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN (-1); + + // Prepare a Long and "define" that in the PropertySet. + CORBA::Long l = 931232; + anyval <<= l; + l = 931233; + anyval >>= l; + CORBA::Any newany(anyval); + propsetdef_->define_property_with_mode ("long_property", + anyval, + CosPropertyService::fixed_normal + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN ( -1); + + + // Prepare a Float and "define" that in the PropertySet. + CORBA::Float f = 3.14F; + anyval <<= f; + f = 4.14F; + anyval >>= f; + propsetdef_->define_property_with_mode ("float_property", + anyval, + CosPropertyService::fixed_readonly + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN ( -1); + + // Prepare a String and "define" that in the PropertySet. + CORBA::String_var strvar (CORBA::string_dup ("Test_String")); + anyval <<= strvar.in (); + const char* newstr; + anyval >>= newstr; + + propsetdef_->define_property ("string_property", + anyval + ACE_ENV_ARG_PARAMETER); + ACE_CHECK_RETURN ( -1); + + return 0; +} + +int +Client::test_get_property_value (ACE_ENV_SINGLE_ARG_DECL) +{ + ACE_TRY + { + // Get the ior property. + CORBA::Any_ptr any_ptr = this->propsetdef_->get_property_value ("PropertySetDef_IOR" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + // Check whether the IOR is fine. + CORBA::Object_var propsetdef_object; + (*any_ptr) >>= CORBA::Any::to_object (propsetdef_object.out ()); + + CosPropertyService::PropertySetDef_var propsetdef = + CosPropertyService::PropertySetDef::_narrow (propsetdef_object.in () + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (CORBA::is_nil (propsetdef.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + "invalid object reference\n"), + -1); + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "get_property_value"); + return -1; + } + ACE_ENDTRY; + ACE_CHECK_RETURN (-1); + return 0; +} + +int +main (int argc, char **argv) +{ + ACE_DECLARE_NEW_CORBA_ENV; + + ACE_TRY + { + Client client; + + if (client.init (argc, + argv + ACE_ENV_ARG_PARAMETER) == -1) + return 1; + ACE_TRY_CHECK; + + // client.run (ACE_ENV_SINGLE_ARG_PARAMETER); + int ret = client.property_tester (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + if (ret != 0) + ACE_DEBUG ((LM_DEBUG, "Test failed\n")); + else + ACE_DEBUG ((LM_DEBUG, "Test succeeded\n")); + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "PropertyService Test : client"); + return -1; + } + ACE_ENDTRY; + ACE_CHECK_RETURN (-1); + + return 0; +} |