diff options
| -rw-r--r-- | TAO/orbsvcs/tests/Property/Makefile | 91 | ||||
| -rw-r--r-- | TAO/orbsvcs/tests/Property/client.cpp | 809 | ||||
| -rw-r--r-- | TAO/orbsvcs/tests/Property/client.h | 105 | ||||
| -rw-r--r-- | TAO/orbsvcs/tests/Property/main.cpp | 589 | ||||
| -rw-r--r-- | TAO/orbsvcs/tests/Property/server.h | 27 |
5 files changed, 1621 insertions, 0 deletions
diff --git a/TAO/orbsvcs/tests/Property/Makefile b/TAO/orbsvcs/tests/Property/Makefile new file mode 100644 index 00000000000..963cd8708c6 --- /dev/null +++ b/TAO/orbsvcs/tests/Property/Makefile @@ -0,0 +1,91 @@ +#---------------------------------------------------------------------------- +# $Id$ +# +# Top-level Makefile for the AVStreams demo of the TAO ORB +# +#---------------------------------------------------------------------------- + +#--------------- +# STL (start) +#--------------- + +include $(STL_ROOT)/config/local.cfg + +CC_INCLUDES += -I$(STD) +CC_INCLUDES += -pta + +CPPFLAGS += \ + -I$(TOOLKIT) \ + $(CC_INCLUDES) \ + $(CC_FLAGS) \ + $(CC_DEFINES) \ + $(CC_EH) \ + $(CC_MT) + +ifndef exceptions +CPPFLAGS += -DOS_NO_EXCEPTION_SPECIFIER +else +CPPFLAGS += -DOS_STL_ASSERT +endif + +LDFLAGS += -L$(STL_ROOT)/lib + +#--------------- +# STL (end) +#--------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +LDLIBS = -lorbsvcs -lospace -lTAO -lrpcsvc + +AVStreams_SERVER_OBJS = server.o +AVStreams_CLIENT_OBJS = client.o + +COSPROPERTY_OBJS = main.o + +BIN = server client +BUILD = $(BIN) +VLDLIBS = $(LDLIBS:%=%$(VAR)) + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +#include $(ACE_ROOT)/include/makeinclude/rules.bin.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU + +ifndef TAO_ROOT +TAO_ROOT = $(ACE_ROOT)/TAO +endif + +LDFLAGS += -L$(TAO_ROOT)/orbsvcs/orbsvcs -L$(TAO_ROOT)/tao +CPPFLAGS += -I$(TAO_ROOT)/orbsvcs -I$(TAO_ROOT) -I$(TAO_ROOT)/tao/compat $(TSS_ORB_FLAG)#-H + +server:$(addprefix $(VDIR),$(AVStreams_SERVER_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(VLDLIBS) $(POSTLINK) + +client:$(addprefix $(VDIR),$(AVStreams_CLIENT_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(VLDLIBS) $(POSTLINK) + +realclean: clean + -/bin/rm -rf + + +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + + + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY + + + + + + diff --git a/TAO/orbsvcs/tests/Property/client.cpp b/TAO/orbsvcs/tests/Property/client.cpp new file mode 100644 index 00000000000..7387e6a7d0c --- /dev/null +++ b/TAO/orbsvcs/tests/Property/client.cpp @@ -0,0 +1,809 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/orbsvcs/tests/CosPropertyService +// +// = FILENAME +// client.cpp +// +// = DESCRIPTION +// Test client for the CosPropertyService. +// +// = AUTHORS +// Alexander Babu Arulanthu <alex@cs.wustl.edu> +// +// ============================================================================ + +#include "client.h" + +Client::Client (void) +{ +} + +// initialize the ORB, get a grip on the remote mmdevice, and store it +// in this->remote_mmdevice_. Also create a stream controlller and a +// local mmdevice. + +int +Client::init (int argc, + char *argv[], + CORBA::Environment &env) +{ + // Init the ORB. + manager_.init (argc, + argv, + env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Open the ORB. + manager_.orb ()->open (); + + // Naming service. + CORBA::Object_var naming_obj = + manager_.orb ()->resolve_initial_references ("NameService"); + if (CORBA::is_nil (naming_obj.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Unable to resolve the Name Service.\n"), + -1); + CosNaming::NamingContext_var naming_context = + CosNaming::NamingContext::_narrow (naming_obj.in (), + env); + TAO_CHECK_ENV_RETURN (env, 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 = naming_context->resolve (propsetdef_name, + env); + TAO_CHECK_ENV_RETURN (env, 1); + + ACE_DEBUG ((LM_DEBUG, "Naming resolve done\n")); + + this->propsetdef_ = CosPropertyService::PropertySetDef::_narrow (propsetdef_obj.in (), + env); + TAO_CHECK_ENV_RETURN (env, -1); + + if (CORBA::is_nil (this->propsetdef_.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + "Couldnot resolve propsetdef in Naming server"), + -1); +} + +// Testing the methods of the property service. + +int +Client::property_tester (CORBA::Environment &env) +{ + // = Testing PropertySet & Iterators. + + // Testing define_property () of PropertySet interface. + this->test_define_property (env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Test the number of properties. + this->test_get_number_of_properties (env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Testing get_all_property_names. + this->test_get_all_property_names (env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Test get_property_value. + this->test_get_property_value (env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Testing delete property. + this->test_delete_property ("no_property",env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Testing get_properties. + this->test_get_properties (env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Testing delete_properties. + this->test_delete_properties (env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Test the number of properties. + this->test_get_number_of_properties (env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Testing define_properties. + this->test_define_properties (env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Test the number of properties. + this->test_get_number_of_properties (env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Testing get_all_property_names. + this->test_get_all_property_names (env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Testing get_all_properties. + this->test_get_all_properties (env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Get the modes of all the properties defined. + this->test_get_property_modes (env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Testing delete_all_properties. + this->test_delete_all_properties (env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Test the number of properties. + this->test_get_number_of_properties (env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Try to get all the properties. + this->test_get_all_properties (env); + TAO_CHECK_ENV_RETURN (env, -1); + + // = Testing PropertySetDef & Iterators. + + // Testing define_property_with_mode. + this->test_define_property_with_mode (env); + TAO_CHECK_ENV_RETURN (env, -1); +} + +// Testing define_property. + +int +Client::test_define_property (CORBA::Environment &env) +{ + ACE_DEBUG ((LM_DEBUG, + "\nChecking define_property\n")); + + CORBA::Any anyval; + + // Prepare a char and "define" that in the PropertySet. + CORBA::Char ch = '#'; + anyval <<= from_char (ch); + ch = '*'; + anyval >>= to_char (ch); + + ACE_DEBUG ((LM_DEBUG, + "Main : Char ch = %c\n", + ch)); + this->propsetdef_->define_property ("char_property", + anyval, + env); + + // Check if that is an user exception, if so, print it out. + if ((env.exception () != 0) && + (CORBA::UserException::_narrow (env.exception ()) != 0)) + { + env.print_exception ("char_property"); + env.clear (); + } + + // Prepare a Short and "define" that in the PropertySet. + CORBA::Short s = 3; + anyval <<= s; + s = 7; + anyval >>= s; + + ACE_DEBUG ((LM_DEBUG, + "Main : Short s = %d\n", + s)); + propsetdef_->define_property ("short_property", + anyval, + env); + + // Check if that is an user exception, if so, print it out. + if ((env.exception () != 0) && + (CORBA::UserException::_narrow (env.exception ()) != 0)) + { + env.print_exception ("char_property"); + env.clear (); + } + + // Prepare a Long and "define" that in the PropertySet. + CORBA::Long l = 931232; + anyval <<= l; + l = 931233; + anyval >>= l; + ACE_DEBUG ((LM_DEBUG, + "Main : Long l = %d\n", + l)); + CORBA::Any newany(anyval); + propsetdef_->define_property ("long_property", + anyval, + env); + + // Check if that is an user exception, if so, print it out. + if ((env.exception () != 0) && + (CORBA::UserException::_narrow (env.exception ()) != 0)) + { + env.print_exception ("char_property"); + env.clear (); + } + + // Prepare a Float and "define" that in the PropertySet. + CORBA::Float f = 3.14; + anyval <<= f; + f = 4.14; + anyval >>= f; + ACE_DEBUG ((LM_DEBUG, + "Main : Float f = %f\n", + f)); + propsetdef_->define_property ("float_property", + anyval, + env); + + // Check if that is an user exception, if so, print it out. + if ((env.exception () != 0) && + (CORBA::UserException::_narrow (env.exception ()) != 0)) + { + env.print_exception ("char_property"); + env.clear (); + } + + // Prepare a String and "define" that in the PropertySet. + ACE_DEBUG ((LM_DEBUG, + "Main: Any holding String\n")); + CORBA::String_var strvar (CORBA::string_dup ("Test_String")); + anyval <<= strvar.in (); + CORBA::String newstr; + anyval >>= newstr; + ACE_DEBUG ((LM_DEBUG, + "Main: String : %s, From any : %s\n", + strvar.in (), + newstr)); + propsetdef_->define_property ("string_property", + anyval, + env); + + // Check if that is an user exception, if so, print it out. + if ((env.exception () != 0) && + (CORBA::UserException::_narrow (env.exception ()) != 0)) + { + env.print_exception ("string_property"); + env.clear (); + } + + return 0; +} + +// Testing get_all_property_names of the PropertySet. + +int +Client::test_get_all_property_names (CORBA::Environment &env) +{ + ACE_DEBUG ((LM_DEBUG, + "\nTesting get_all_property_names ()\n")); + + // Get the size. + CORBA::ULong num_of_properties = + propsetdef_->get_number_of_properties (env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Get half on the names and half of on the iterator. + CORBA::ULong how_many = num_of_properties / 2; + CosPropertyService::PropertyNames_var names_var; + CosPropertyService::PropertyNamesIterator_var iterator_var; + propsetdef_->get_all_property_names (how_many, + names_var.out (), + iterator_var.out (), + env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Print out the names in the names-sequence. + 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) + { + CosPropertyService::PropertyName_var name_var; + + while (iterator_var->next_one (name_var.out (), env) == CORBA::B_TRUE) + { + TAO_CHECK_ENV_RETURN (env, -1); + ACE_DEBUG ((LM_DEBUG, "%s\n", name_var.in ())); + } + + TAO_CHECK_ENV_RETURN (env, -1); + } +} + +// Test get_properties. Give a sequence of names and get all their +// properties. + +int +Client::test_get_properties (CORBA::Environment &env) +{ + // 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. + ACE_DEBUG ((LM_DEBUG, "\nTesting get_properties\n")); + CosPropertyService::PropertyNames_var names; + CosPropertyService::PropertyNames_ptr names_ptr; + + ACE_NEW_RETURN (names_ptr, + CosPropertyService::PropertyNames, + -1); + names = names_ptr; + + names->length (3); + names [0] = CORBA::string_dup ("float_property"); + //names [1] = CORBA::string_dup ("string_property"); + names [1] = CORBA::string_dup ("long_property"); + names [2] = CORBA::string_dup ("char_property"); + //names [2] = CORBA::string_dup ("no_property"); + + CosPropertyService::Properties_var properties; + + // Get the properties. + CORBA::Boolean return_val = propsetdef_->get_properties (names.in (), + properties.out (), + env); + TAO_CHECK_ENV_RETURN (env, -1); + + 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::Any::dump (properties [pi].property_value); + } + } + return 0; +} + +// Testing, get_number_of_properties. + +int +Client::test_get_number_of_properties (CORBA::Environment &env) +{ + ACE_DEBUG ((LM_DEBUG, + "\nNumber of props : %d\n", + this->propsetdef_->get_number_of_properties (env))); + TAO_CHECK_ENV_RETURN (env, -1); + + return 0; +} + +// Test delete_property. + +int +Client::test_delete_property (CORBA::String property_name, + CORBA::Environment &env) +{ + ACE_DEBUG ((LM_DEBUG, "\nDeleting %s\n",property_name)); + + TAO_TRY + { + this->propsetdef_->delete_property (property_name, TAO_TRY_ENV); + TAO_CHECK_ENV; + } + TAO_CATCH (CORBA::UserException, ex) + { + TAO_TRY_ENV.print_exception ("User exception"); + return -1; + } + TAO_CATCHANY + { + TAO_TRY_ENV.print_exception ("Not an user exception"); + return -1; + } + TAO_ENDTRY; + + 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 (CORBA::Environment &env) +{ + ACE_DEBUG ((LM_DEBUG, + "\nChecking delete_properties\n")); + 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"); + ACE_DEBUG ((LM_DEBUG, + "Length of sequence %d, Maxlength : %d\n", + prop_names.length (), + prop_names.maximum ())); + this->propsetdef_->delete_properties (prop_names, + env); + TAO_CHECK_ENV_RETURN (env, 0); + + return 0; +} + +// Defines a sequnce of properties containing, char, short, long, +// float in the property set. + +int +Client::test_define_properties (CORBA::Environment &env) +{ + ACE_DEBUG ((LM_DEBUG, + "\nChecking define_properties\n")); + CosPropertyService::Properties nproperties; + nproperties.length (4); + CORBA::Any anyval; + // Prepare a char and "define" that in the PropertySet. + CORBA::Char ch = '#'; + anyval <<= from_char (ch); + ch = '*'; + anyval >>= to_char (ch); + nproperties[0].property_name = CORBA::string_copy ("char_property"); + nproperties[0].property_value <<= 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_copy ("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_copy ("long_property"); + nproperties[2].property_value <<= l; + + // Prepare a Float and "define" that in the PropertySet. + CORBA::Float f = 3.14; + anyval <<= f; + f = 4.14; + anyval >>= f; + nproperties[3].property_name = CORBA::string_copy ("float_property"); + nproperties[3].property_value <<= f; + + // Define this sequence of properties now. + this->propsetdef_->define_properties (nproperties, env); + TAO_CHECK_ENV_RETURN (env, -1); + + return 0; +} + +// Test get_all_properties. + +int +Client::test_get_all_properties (CORBA::Environment &env) +{ + ACE_DEBUG ((LM_DEBUG, + "\nTesting get_all_properties\n")); + // Get the number of current properties. + CORBA::ULong num_of_properties = + this->propsetdef_->get_number_of_properties (env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Get half on the properties and half of on the iterator. + CORBA::ULong how_many = 0; + CosPropertyService::Properties_var properties; + CosPropertyService::PropertiesIterator_var iterator; + propsetdef_->get_all_properties (how_many, + properties.out (), + iterator.out (), + env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Print out the properties now. + 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. + CORBA::Any::dump (properties [pi].property_value); + } + } + + // Pass thru the iterator. + if (iterator.ptr () != 0) + { + CosPropertyService::Property_var property; + + while (iterator->next_one (property.out (), env) != CORBA::B_FALSE) + { + TAO_CHECK_ENV_RETURN (env, -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 >>= 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) + { + CORBA::String 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)); + } + } + TAO_CHECK_ENV_RETURN (env, -1); + } +} + +// Testing define property with mode. +// Defines char, short, long and float properties with different modes. +int +Client::test_define_property_with_mode (CORBA::Environment &env) +{ + ACE_DEBUG ((LM_DEBUG, + "\nChecking define_property_with_mode\n")); + + CORBA::Any anyval; + + // Prepare a char and "define" that in the PropertySet. + CORBA::Char ch = '#'; + anyval <<= from_char (ch); + ch = '*'; + anyval >>= to_char (ch); + + ACE_DEBUG ((LM_DEBUG, + "Main : Char ch = %c\n", + ch)); + this->propsetdef_->define_property_with_mode ("char_property", + anyval, + CosPropertyService::normal, + env); + // Check if that is an user exception, if so, print it out. + if ((env.exception () != 0) && + (CORBA::UserException::_narrow (env.exception ()) != 0)) + { + env.print_exception ("char_property"); env.clear (); + } + + // Prepare a Short and "define" that in the PropertySet. + CORBA::Short s = 3; + anyval <<= s; + s = 7; + anyval >>= s; + + ACE_DEBUG ((LM_DEBUG, + "Main : Short s = %d\n", + s)); + propsetdef_->define_property_with_mode ("short_property", + anyval, + CosPropertyService::read_only, + env); + // Check if that is an user exception, if so, print it out. + if (env.exception () != 0) + { + env.print_exception ("char_property"); + if (CORBA::UserException::_narrow (env.exception ()) != 0) + env.clear (); + else + return -1; + } + + + // Prepare a Long and "define" that in the PropertySet. + CORBA::Long l = 931232; + anyval <<= l; + l = 931233; + anyval >>= l; + ACE_DEBUG ((LM_DEBUG, + "Main : Long l = %d\n", + l)); + CORBA::Any newany(anyval); + propsetdef_->define_property_with_mode ("long_property", + anyval, + CosPropertyService::fixed_normal, + env); + TAO_CHECK_ENV_RETURN (env, -1); + + + // Prepare a Float and "define" that in the PropertySet. + CORBA::Float f = 3.14; + anyval <<= f; + f = 4.14; + anyval >>= f; + ACE_DEBUG ((LM_DEBUG, + "Main : Float f = %f\n", + f)); + propsetdef_->define_property_with_mode ("float_property", + anyval, + CosPropertyService::fixed_readonly, + env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Prepare a String and "define" that in the PropertySet. + ACE_DEBUG ((LM_DEBUG, + "Main: Any holding String\n")); + CORBA::String_var strvar (CORBA::string_dup ("Test_String")); + anyval <<= strvar.in (); + CORBA::String newstr; + anyval >>= newstr; + + ACE_DEBUG ((LM_DEBUG, + "Main: String : %s, From any : %s\n", + strvar.in (), + newstr)); + propsetdef_->define_property ("string_property", + anyval, + env); + TAO_CHECK_ENV_RETURN (env, -1); +} + +int +Client::test_get_property_value (CORBA::Environment &env) +{ + TAO_TRY + { + // Get the ior property. + CORBA::Any_ptr any_ptr = this->propsetdef_->get_property_value ("PropertySetDef_IOR", + TAO_TRY_ENV); + TAO_CHECK_ENV; + + ACE_DEBUG ((LM_DEBUG, "Property value received successfully\n")); + + // Check whether the IOR is fine. + CORBA::Object_var propsetdef_object; + (*any_ptr) >>= to_object (propsetdef_object); + + CosPropertyService::PropertySetDef_var propsetdef = + CosPropertyService::PropertySetDef::_narrow (propsetdef_object.in (), + TAO_TRY_ENV); + TAO_CHECK_ENV; + + if (CORBA::is_nil (propsetdef.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + "invalid object reference\n"), + -1); + + ACE_DEBUG ((LM_DEBUG, "IOR retrieved. Seems to be in good shape\n")); + } + TAO_CATCHANY + { + TAO_TRY_ENV.print_exception ("get_property_value"); + return -1; + } + TAO_ENDTRY; +} + +int +Client::test_delete_all_properties (CORBA::Environment &env) +{ + ACE_DEBUG ((LM_DEBUG, "\nTesting delete_all_properties\n")); + + TAO_TRY + { + // Delete all properties. + this->propsetdef_->delete_all_properties (TAO_TRY_ENV); + TAO_CHECK_ENV_RETURN (TAO_TRY_ENV, 0); + } + TAO_CATCHANY + { + TAO_TRY_ENV.print_exception ("test_delete_all_properties"); + return -1; + } + TAO_ENDTRY; + + return 0; +} + +int +Client::test_get_property_modes (CORBA::Environment &env) +{ + // Get all the names and then get all their modes, print'em. + ACE_DEBUG ((LM_DEBUG, + "\nTesting get_property_modes ()\n")); + + // Get the size. + CORBA::ULong num_of_properties = + propsetdef_->get_number_of_properties (env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Get all the names in the sequence. + CORBA::ULong how_many = num_of_properties; + CosPropertyService::PropertyNames_var names_var; + CosPropertyService::PropertyNamesIterator_var iterator_var; + propsetdef_->get_all_property_names (how_many, + names_var.out (), + iterator_var.out (), + env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Get modes for all these names. + CosPropertyService::PropertyModes_var modes; + propsetdef_->get_property_modes (names_var.in (), + modes.out (), + env); + TAO_CHECK_ENV_RETURN (env, -1); + + // Print the names and the modes. + if (modes.ptr () != 0) + { + CORBA::ULong len = modes->length (); + + for (CORBA::ULong mi = 0; mi < len; mi++) + // Print the property_name and the mode. + ACE_DEBUG ((LM_DEBUG, + "%s, Mode %d\n", + modes [mi].property_name.in (), + modes [mi].property_mode)); + } +} + +int +main (int argc, char **argv) +{ + TAO_TRY + { + Client client; + + if (client.init (argc, + argv, + TAO_TRY_ENV) == -1) + return 1; + TAO_CHECK_ENV; + + // client.run (TAO_TRY_ENV); + client.property_tester (TAO_TRY_ENV); + TAO_CHECK_ENV; + } + TAO_CATCHANY + { + TAO_TRY_ENV.print_exception ("AVStreams: client"); + return -1; + } + TAO_ENDTRY; +} diff --git a/TAO/orbsvcs/tests/Property/client.h b/TAO/orbsvcs/tests/Property/client.h new file mode 100644 index 00000000000..fac248d6fd3 --- /dev/null +++ b/TAO/orbsvcs/tests/Property/client.h @@ -0,0 +1,105 @@ +/* -*- C++ -*- */ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/orbsvcs/tests/CosPropertyService +// +// = FILENAME +// client.h +// +// = DESCRIPTION +// Test client for the CosPropertyService. +// +// = AUTHORS +// Alexander Babu Arulanthu <alex@cs.wustl.edu> +// +// ============================================================================ + +#if !defined (COSPROPERTYSERVICE_CLIENT_H) +#define COSPROPERTYSERVICE_CLIENT_H + +#include "ace/Synch.h" +#include "ace/Task.h" +#include "ace/Thread_Manager.h" +#include "ace/Get_Opt.h" +#include "tao/TAO.h" +#include "orbsvcs/Property/CosPropertyService_i.h" +#include "orbsvcs/Naming/Naming_Utils.h" + +class Client +{ + // = TITLE + // Client for A/V Streams demo. + // + // = DESCRIPTION + // Encapsulates client functionality. +public: + Client (void); + // Constructor. + + int init (int argc, + char **argv, + CORBA::Environment &env); + // Initialize the ORB etc, and bind the MMDevices. + + int run (CORBA::Environment &env); + // Run the client. This will call StreamCtrl::bind_devs. + + int property_tester (CORBA::Environment &env); + // Testing the property service methods. + +protected: + int bind_to_remote_mmdevice (int argc, + char *argv[], + CORBA::Environment &env); + // Bind to the remote MMDevice. + + // = Property Testing. + + int test_define_property (CORBA::Environment &env); + // Testing the define property method. + + int test_get_number_of_properties (CORBA::Environment &env); + // Testing the number of properties, currently in the Property Set. + + int test_get_all_property_names (CORBA::Environment &env); + //Testing get_all_property_names. + + int test_get_property_value (CORBA::Environment &env); + // Testing get_property_value. + + int test_get_properties (CORBA::Environment &env); + //Testing get_properties. Give the names and get their properties. + + int test_get_all_properties (CORBA::Environment &env); + // Testing get_all_properties. + + int test_delete_property (CORBA::String property_name, + CORBA::Environment &env); + // Testing delete_property. + + int test_delete_properties (CORBA::Environment &env); + // Testing delete_properties. + + int test_define_properties (CORBA::Environment &env); + // Defining a sequence of properties. + + int test_define_property_with_mode (CORBA::Environment &env); + // Defines properties with various modes. + + int test_delete_all_properties (CORBA::Environment &env); + // Deleting all the properties. + + int test_get_property_modes (CORBA::Environment &env); + // Getting the modes of some properties. + + TAO_ORB_Manager manager_; + // The ORB manager, handles ORB initialization etc. + + CosPropertyService::PropertySetDef_var propsetdef_; + // To test propertySetDef interface. +}; + +#endif /* COSPROPERTYSERVICE_CLIENT_H */ diff --git a/TAO/orbsvcs/tests/Property/main.cpp b/TAO/orbsvcs/tests/Property/main.cpp new file mode 100644 index 00000000000..893bbe06bbb --- /dev/null +++ b/TAO/orbsvcs/tests/Property/main.cpp @@ -0,0 +1,589 @@ +// $Id$ + +// ========================================================================================================= +// +// = FILE +// Program to test the property services. +// +// = DESCRIPTION +// Here all the objects are at one address space. See the +// client.cpp and server.cpp to see property calls on remote +// objects. +// +// = AUTHOR +// Alexander Babu Arulanthu <alex@cs.wustl.edu> +// +// ========================================================================================================= + +#include "orbsvcs/CosPropertyServiceS.h" +#include "orbsvcs/Property/CosPropertyService_i.h" + +class TAO_PropertySet_Tester +{ + // = TITLE + // The testing code for the PropertySet interface are grouped + // under the functions of this class. + // + // = DESCRIPTION + // Go thru the functions to understand the usage of the various + // methods of the PropertySet interaface. +public: + friend class TAO_PropertyNamesIterator_Tester; + // He has to instantiate TAO_NamesIterator class using the instance + // of TAO_PropertySet. + + TAO_PropertySet_Tester (void); + // Constructor. + + ~TAO_PropertySet_Tester (void); + // Destructor. + + int test_define_property (CORBA::Environment &env); + // Defines a char,a short, a long, a float and a string property. + + int test_get_number_of_properties (CORBA::Environment &env); + // Gets the number of properties currently defined in the PropertySet. + + int test_delete_property (const char *property_name, + CORBA::Environment &env); + // Delete a given property. + + int test_is_property_defined (CORBA::Environment &env); + // Check the following properties are defined or + // no. "char_property", "short_property" and a "string_property". + + int test_get_property_value (CORBA::Environment &env); + // Get the "float_property" and "string_property" and print them + // out. + + int test_delete_properties (CORBA::Environment &env); + // Delete char, short,long, and string properties. + + int test_delete_all_properties (CORBA::Environment &env); + // Delete all the properties. + + int test_define_properties (CORBA::Environment &env); + // Define a sequence of properties. a char, a short, a long, a float + // and a string. + +private: + TAO_PropertySet property_set_; + // The PropertySet. +}; + +class TAO_PropertyNamesIterator_Tester +{ + // = TITLE + // The testing code for the PropertyNamesIterator interface are grouped + // under the functions of this class. + // + // = DESCRIPTION + // Go thru the functions to understand the usage of the various + // methods of the PropertyNamesIterator interaface. +public: + TAO_PropertyNamesIterator_Tester (TAO_PropertySet_Tester &propertyset_tester); + // Constructor. To make names iterator from the property set object. + + ~TAO_PropertyNamesIterator_Tester (void); + // Destructor. + + int test_next_one (CORBA::Environment &env); + // Test next one method. Iterate thru all the names in the + // PropertySet and print them out. + + int test_reset (CORBA::Environment &env); + // Test the reset method. + + int test_next_n (size_t n, CORBA::Environment &env); + // Test the next_n method. +private: + TAO_PropertyNamesIterator iterator_; + // Our names iterator. +}; + + +// Constructor. +TAO_PropertySet_Tester::TAO_PropertySet_Tester (void) +{ +} + +// Destructor. +TAO_PropertySet_Tester::~TAO_PropertySet_Tester (void) +{ +} + +// Defines a char, a short, a long, a float and a string. +int +TAO_PropertySet_Tester::test_define_property (CORBA::Environment &env) +{ + ACE_DEBUG ((LM_DEBUG, + "\nChecking define_property\n")); + + CORBA::Any anyval; + + // Prepare a char and "define" that in the PropertySet. + CORBA::Char ch = '#'; + anyval <<= from_char (ch); + ch = '*'; + anyval >>= to_char (ch); + ACE_DEBUG ((LM_DEBUG, + "Main : Char ch = %c\n", + ch)); + property_set_.define_property ("char_property", + anyval, + env); + TAO_CHECK_ENV_RETURN (env, 1); + + // Prepare a Short and "define" that in the PropertySet. + CORBA::Short s = 3; + anyval <<= s; + s = 7; + anyval >>= s; + ACE_DEBUG ((LM_DEBUG, + "Main : Short s = %d\n", + s)); + property_set_.define_property ("short_property", + anyval, + env); + TAO_CHECK_ENV_RETURN (env, 1); + + + // Prepare a Long and "define" that in the PropertySet. + CORBA::Long l = 931232; + anyval <<= l; + l = 931233; + anyval >>= l; + ACE_DEBUG ((LM_DEBUG, + "Main : Long l = %d\n", + l)); + CORBA::Any newany(anyval); + + property_set_.define_property ("long_property", + anyval, + env); + TAO_CHECK_ENV_RETURN (env, 1); + + // Prepare a Float and "define" that in the PropertySet. + CORBA::Float f = 3.14; + anyval <<= f; + f = 4.14; + anyval >>= f; + ACE_DEBUG ((LM_DEBUG, + "Main : Float f = %f\n", + f)); + property_set_.define_property ("float_property", + anyval, + env); + TAO_CHECK_ENV_RETURN (env, 1); + + // Prepare a String and "define" that in the PropertySet. + ACE_DEBUG ((LM_DEBUG, + "Main: Any holding String\n")); + CORBA::String_var strvar (CORBA::string_dup ("Test_String")); + anyval <<= strvar.in (); + CORBA::String newstr; + anyval >>= newstr; + ACE_DEBUG ((LM_DEBUG, + "Main: String : %s, From any : %s\n", + strvar.in (), + newstr)); + property_set_.define_property ("string_property", + anyval, + env); + TAO_CHECK_ENV_RETURN (env, 1); + + return 0; +} + +// Testing, get_number_of_properties. +int +TAO_PropertySet_Tester::test_get_number_of_properties (CORBA::Environment &env) +{ + ACE_DEBUG ((LM_DEBUG, + "Main : Number of props : %d\n", + property_set_.get_number_of_properties (env))); + TAO_CHECK_ENV_RETURN (env, 1); + + return 0; +} + +// Testing the delete_property. Delets property, with the given name, +// if that exsists. +int +TAO_PropertySet_Tester::test_delete_property (const char *property_name, + CORBA::Environment &env) +{ + ACE_DEBUG ((LM_DEBUG, "\nChecking delete_property\n")); + property_set_.delete_property (property_name, + env); + TAO_CHECK_ENV_RETURN (env, 1); + + return 0; +} + +// Gets the value of "short_property" and "string_property". + +int +TAO_PropertySet_Tester::test_get_property_value (CORBA::Environment &env) +{ + ACE_DEBUG ((LM_DEBUG, + "\nChecking get_property_value\n")); + + CORBA::Any_ptr anyptr = property_set_.get_property_value ("short_property", + env); + TAO_CHECK_ENV_RETURN (env, 1); + + // Get the short value. + if (anyptr != 0) + { + CORBA::Short s; + *anyptr >>= s; + ACE_DEBUG ((LM_DEBUG, + "Short %d\n", + s)); + } + else + ACE_DEBUG ((LM_DEBUG, + "Short property not found\n")); + // Get the string. + anyptr = property_set_.get_property_value ("string_property", + env); + TAO_CHECK_ENV_RETURN (env, 1); + if (anyptr != 0) + { + CORBA::String str; + *anyptr >>= str; + ACE_DEBUG ((LM_DEBUG, + "Str %s\n", str)); + } + else + ACE_DEBUG ((LM_DEBUG, + "string_property not found\n")); + return 0; +} + +// Check the following properties are defined or no. "short_property", +// "string_property" and "char_property". + +int +TAO_PropertySet_Tester::test_is_property_defined (CORBA::Environment &env) +{ + ACE_DEBUG ((LM_DEBUG, + "\nChecking is_property_defined ()\n")); + if (property_set_.is_property_defined ("short_property", + env) == CORBA::B_FALSE) + ACE_DEBUG ((LM_DEBUG, + "short_property not defined\n")); + else + ACE_DEBUG ((LM_DEBUG, + "short_property defined\n")); + TAO_CHECK_ENV_RETURN (env, 1); + if (property_set_.is_property_defined ("string_property", + env) == CORBA::B_FALSE) + ACE_DEBUG ((LM_DEBUG, + "string_property not defined\n")); + else + ACE_DEBUG ((LM_DEBUG, + "string_property defined\n")); + TAO_CHECK_ENV_RETURN (env, 1); + if (property_set_.is_property_defined ("char_property", + env) == CORBA::B_FALSE) + ACE_DEBUG ((LM_DEBUG, + "char_property not defined\n")); + else + ACE_DEBUG ((LM_DEBUG, + "char_property defined\n")); + TAO_CHECK_ENV_RETURN (env, 1); + + return 0; +} + +// Make a sequence of property names and delete them from the +// PropertySet. Deleting char, short, long, float and string +// properties. +int +TAO_PropertySet_Tester::test_delete_properties (CORBA::Environment &env) +{ + ACE_DEBUG ((LM_DEBUG, + "\nChecking delete_properties == Deleting a sequence of Properties\n")); + CosPropertyService::PropertyNames prop_names; + prop_names.length (4); + 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 ("float_property"); + ACE_DEBUG ((LM_DEBUG, + "Length of sequence %d, Maxlength : %d\n", + prop_names.length (), + prop_names.maximum ())); + property_set_.delete_properties (prop_names, + env); + TAO_CHECK_ENV_RETURN (env, 0); + + return 0; +} + +// Defines a sequnce of properties containing, char, short, long, +// float and string property in the property set. +int +TAO_PropertySet_Tester::test_define_properties (CORBA::Environment &env) +{ + ACE_DEBUG ((LM_DEBUG, + "\nChecking define_properties == Defining sequence of properties\n")); + // TAO_TRY + // { + CosPropertyService::Properties nproperties; + nproperties.length (5); + CORBA::Any anyval; + // Prepare a char and "define" that in the PropertySet. + CORBA::Char ch = '#'; + anyval <<= from_char (ch); + ch = '*'; + anyval >>= to_char (ch); + nproperties[0].property_name = CORBA::string_copy ("char_property"); + nproperties[0].property_value <<= 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_copy ("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_copy ("long_property"); + nproperties[2].property_value <<= l; + + // Prepare a Float and "define" that in the PropertySet. + CORBA::Float f = 3.14; + anyval <<= f; + f = 4.14; + anyval >>= f; + nproperties[3].property_name = CORBA::string_copy ("float_property"); + nproperties[3].property_value <<= f; + + // Prepare a String and "define" that in the PropertySet. + CORBA::String_var strvar (CORBA::string_dup ("Test_String")); + anyval <<= strvar.in (); + nproperties[4].property_name = CORBA::string_copy ("string_property"); + nproperties[4].property_value <<= strvar.in (); + + // Define this sequence of properties now. + property_set_.define_properties (nproperties, env); + TAO_CHECK_ENV_RETURN (env, 1); + + return 0; +} + +// Delete all the properties. +int +TAO_PropertySet_Tester::test_delete_all_properties (CORBA::Environment &env) +{ + // Deleting all the properties + ACE_DEBUG ((LM_DEBUG, + "\nChecking delete_all_properties\n")); + if (property_set_.delete_all_properties (env) == CORBA::B_TRUE) + ACE_DEBUG ((LM_DEBUG, + "All properties deleted, I guess\n")); + else + ACE_DEBUG ((LM_DEBUG, + "delete_all_properties failed\n")); + return 0; +} + +// Constructor. To make names iterator from the property set object. +TAO_PropertyNamesIterator_Tester::TAO_PropertyNamesIterator_Tester (TAO_PropertySet_Tester &propertyset_tester) + : iterator_ (propertyset_tester.property_set_) +{ +} + +// Destructor. +TAO_PropertyNamesIterator_Tester::~TAO_PropertyNamesIterator_Tester (void) +{ +} + +// Test next one method. Iterate thru all the names in the +// PropertySet and print them out. +int +TAO_PropertyNamesIterator_Tester::test_next_one (CORBA::Environment &env) +{ + CORBA::String_var strvar; + ACE_DEBUG ((LM_DEBUG, + "\nTesting next_one of NamesIterator, Iterating thru names.\n")); + // Let us iterate, now. + while (iterator_.next_one (strvar.out (), env) != CORBA::B_FALSE) + { + TAO_CHECK_ENV_RETURN (env, 1); + ACE_DEBUG ((LM_DEBUG, "Str : %s\n", strvar.in ())); + } + return 0; +} + +// Reset the names iterator. +int +TAO_PropertyNamesIterator_Tester::test_reset (CORBA::Environment &env) +{ + ACE_DEBUG ((LM_DEBUG, + "Resetting (reset ()) the NamesIterator.")); + iterator_.reset (env); + TAO_CHECK_ENV_RETURN (env, 1); + return 0; +} + +// Test the next_n method. Get the next n names and print them all. +int +TAO_PropertyNamesIterator_Tester::test_next_n (size_t n, + CORBA::Environment &env) +{ + CosPropertyService::PropertyNames_var pnames_var; + ACE_DEBUG ((LM_DEBUG, + "Checking next_n (), next %d\n", + n)); + if (iterator_.next_n (n, pnames_var.out (), env) == CORBA::B_FALSE) + { + // Return if no more items in the iterator. + TAO_CHECK_ENV_RETURN (env, 1); + ACE_DEBUG ((LM_DEBUG, + "Iterator has no more items\n")); + return 0; + } + TAO_CHECK_ENV_RETURN (env, 1); + for (size_t i = 0; i < pnames_var.in ().length (); i++) + ACE_DEBUG ((LM_DEBUG, + "str %s \n", + (const char *) pnames_var[i])); + return 0; +} + +int +main (int argc, char *argv []) +{ + TAO_TRY + { + CORBA::ORB_var orb_var = CORBA::ORB_init (argc, + argv, + "internet", + TAO_TRY_ENV); + TAO_CHECK_ENV; + + // = Checking PropertySet interface. + + ACE_DEBUG ((LM_DEBUG, + "\nTAO_PropertySet Testing\n")); + TAO_PropertySet_Tester propertyset_tester; + + // Checking define_property. define a char, a short,a long, a float + // and a string. + propertyset_tester.test_define_property (TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Test the number of properties and print it out. + propertyset_tester.test_get_number_of_properties (TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Test delete property. Delete "string_property" + propertyset_tester.test_delete_property ("string_property", TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Test the number of properties and print it out. + propertyset_tester.test_get_number_of_properties (TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Test delete_properties. Delete char, short, long and float. + propertyset_tester.test_delete_properties (TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Test the number of properties and print it out. + propertyset_tester.test_get_number_of_properties (TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Define a sequence of properties. char, short, long, float and + // string. + propertyset_tester.test_define_properties (TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Test the number of properties and print it out. + propertyset_tester.test_get_number_of_properties (TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Checking get_property_value. get the value of short and string. + propertyset_tester.test_get_property_value (TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Checking delete_all_properties. + propertyset_tester.test_delete_all_properties (TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Test the number of properties and print it out. + propertyset_tester.test_get_number_of_properties (TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Define a sequence of properties. char, short, long, float and + // string. + propertyset_tester.test_define_properties (TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Test the number of properties and print it out. + propertyset_tester.test_get_number_of_properties (TAO_TRY_ENV); + TAO_CHECK_ENV; + + // = Checking the PropertyNamesIterator interface. + + ACE_DEBUG ((LM_DEBUG, + "\nTAO_PropertyNamesIterator Testing\n")); + + // Construct the names iterator from the PropertySet object. + TAO_PropertyNamesIterator_Tester names_iterator_tester (propertyset_tester); + + // Checking next_one. Iterate thru the property names. + names_iterator_tester.test_next_one (TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Checking the reset () method. + names_iterator_tester.test_reset (TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Iterating again thru the property names. + names_iterator_tester.test_next_one (TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Reset again. + names_iterator_tester.test_reset (TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Checking next_n. Prints out all the names it has got. + names_iterator_tester.test_next_n (6, TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Try next_n without resetting. + names_iterator_tester.test_next_n (6, TAO_TRY_ENV); + TAO_CHECK_ENV; + } + TAO_CATCH (CORBA::SystemException, sysex) + { + TAO_TRY_ENV.print_exception ("System Exception"); + return -1; + } + TAO_CATCH (CORBA::UserException, userex) + { + TAO_TRY_ENV.print_exception ("User Exception"); + return -1; + } + TAO_ENDTRY; + return 0; +} + + + + + + + + + + diff --git a/TAO/orbsvcs/tests/Property/server.h b/TAO/orbsvcs/tests/Property/server.h new file mode 100644 index 00000000000..06f6b41a455 --- /dev/null +++ b/TAO/orbsvcs/tests/Property/server.h @@ -0,0 +1,27 @@ +/* -*- C++ -*- */ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/orbsvcs/tests/CosPropertyService +// +// = FILENAME +// server.h +// +// = DESCRIPTION +// Test server for the CosPropertyService. +// +// = AUTHORS +// Alexander Babu Arulanthu <alex.cs.wustl.edu> +// +// ============================================================================ + +#if !defined (COSPROPERTYSERVICE_SERVER_H) +#define COSPROPERTYSERVICE_SERVER_H + +#include "tao/TAO.h" +#include "orbsvcs/Property/CosPropertyService_i.h" +#include "orbsvcs/Naming/Naming_Utils.h" + +#endif /* COSPROPERTYSERVICE_SERVER_H */ |