From fdb2c99dcc82b15544bd050a22bf41f94e0c2902 Mon Sep 17 00:00:00 2001 From: sma Date: Wed, 29 Feb 2012 16:55:18 +0000 Subject: ChangeLogTag: Wed Feb 29 16:36:300 UTC 2012 Simon Massey Impliment DynValue, DynValueBox and DynValueCommon types --- TAO/tests/DynValue_Test/Analyzer.cpp | 542 ++++++++++++ TAO/tests/DynValue_Test/Analyzer.h | 60 ++ TAO/tests/DynValue_Test/DynValue_Test.idl | 36 + TAO/tests/DynValue_Test/DynValue_Test.mpc | 28 + TAO/tests/DynValue_Test/ValueTypes_impl.cpp | 152 ++++ TAO/tests/DynValue_Test/ValueTypes_impl.h | 111 +++ TAO/tests/DynValue_Test/main.cpp | 1231 +++++++++++++++++++++++++++ TAO/tests/DynValue_Test/run_test.pl | 22 + 8 files changed, 2182 insertions(+) create mode 100644 TAO/tests/DynValue_Test/Analyzer.cpp create mode 100644 TAO/tests/DynValue_Test/Analyzer.h create mode 100644 TAO/tests/DynValue_Test/DynValue_Test.idl create mode 100644 TAO/tests/DynValue_Test/DynValue_Test.mpc create mode 100644 TAO/tests/DynValue_Test/ValueTypes_impl.cpp create mode 100644 TAO/tests/DynValue_Test/ValueTypes_impl.h create mode 100644 TAO/tests/DynValue_Test/main.cpp create mode 100755 TAO/tests/DynValue_Test/run_test.pl (limited to 'TAO/tests/DynValue_Test') diff --git a/TAO/tests/DynValue_Test/Analyzer.cpp b/TAO/tests/DynValue_Test/Analyzer.cpp new file mode 100644 index 00000000000..22356bb9d12 --- /dev/null +++ b/TAO/tests/DynValue_Test/Analyzer.cpp @@ -0,0 +1,542 @@ +// $Id$ + +#include "Analyzer.h" +#include "tao/DynamicAny/DynCommon.h" + +DynAnyAnalyzer::DynAnyAnalyzer (int argc, ACE_TCHAR *argv[]) + : level_ (1u), + orb_ (CORBA::ORB_init (argc, argv)), + dany_fact_ (0) +{ + if (CORBA::is_nil (orb_.in ())) + { + ACE_DEBUG ((LM_ERROR, "Could not init orb\n")); + throw 0; + } + + CORBA::Object_var + obj (orb_->resolve_initial_references ("DynAnyFactory")); + dany_fact_ = DynamicAny::DynAnyFactory::_narrow(obj.in ()); + if (CORBA::is_nil (dany_fact_.in ())) + { + ACE_DEBUG ((LM_ERROR, "Nil dynamic any factory after narrow\n")); + throw 0; + } +} + +DynamicAny::DynAny_ptr +DynAnyAnalyzer::DynAny_NoTrunc (const CORBA::Any &any) +{ + return this->dany_fact_ + ->create_dyn_any_without_truncation (any); +} + +DynamicAny::DynAny_ptr +DynAnyAnalyzer::DynAny (const CORBA::Any &any) +{ + return this->dany_fact_ + ->create_dyn_any (any); +} + +DynamicAny::DynAny_ptr +DynAnyAnalyzer::DynAny (const CORBA::TypeCode_ptr &tc) +{ + return this->dany_fact_ + ->create_dyn_any_from_type_code (tc); +} + +void +DynAnyAnalyzer::register_factory ( + CORBA::ValueFactoryBase_var factory) +{ + factory_id * new_fact ( + dynamic_cast (factory.in()) ); + tab("Registering factory for ValueType "); + ACE_DEBUG ((LM_DEBUG, "%C\n", new_fact->id ())); + CORBA::ValueFactoryBase_var old_fact ( + orb_->register_value_factory ( + new_fact->id (), factory.in () ) ); +} + +void +DynAnyAnalyzer::get_base_types ( + CORBA::TypeCode_ptr tc, + BaseTypesList_t &base_types, + CORBA::ULong *total_member_count) +{ + // First initalize to the fully derived type we are + // starting with. + + CORBA::ULong numberOfBases = 1u; + base_types.size (numberOfBases); + base_types[0] = TAO_DynAnyFactory::strip_alias (tc); + if (total_member_count) + { + *total_member_count = base_types[0]->member_count (); + } + + // Obtain each derived type's basetype and add this to the list + + CORBA::TypeCode_var + base (base_types[0]->concrete_base_type()); + while (0 != base.in() && + CORBA::tk_value == + (base = TAO_DynAnyFactory::strip_alias (base.in())) + ->kind ()) + { + if (total_member_count) + { + *total_member_count += base->member_count (); + } + + base_types.size (numberOfBases + 1); + base_types[numberOfBases++] = CORBA::TypeCode::_duplicate (base); + base = base->concrete_base_type(); + } +} + +CORBA::TypeCode_ptr +DynAnyAnalyzer::get_correct_base_type ( + const BaseTypesList_t &base_types, + CORBA::ULong &index) +{ + // We work backwards through the list of derived types, + // so index 0 is the first member of the extreme base type + // (assuming it has any members) once we run out of that + // base types members we move up the list to the next + // derived type until that type's members are exhausted + // and so on until we reach the member we have asked for. + + CORBA::ULong + currentBase = base_types.size (); + if (!currentBase) + { + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("TAO_DynValue_i::get_correct_base_type () ") + ACE_TEXT ("BaseTypesList_t is not initialised\n"))); + return 0; + } + + while (base_types[--currentBase]->member_count () <= index) + { + index -= base_types[currentBase]->member_count (); + if (!currentBase) + { + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("TAO_DynValue_i::get_correct_base_type () ") + ACE_TEXT ("BaseTypesList_t is not large enough\n"))); + return 0; + } + } + + // Note that the "index" has now been reduced to the range + // of the returning base_type. + return base_types[currentBase].in (); +} + +#define CASEE(type,CT,str) case CORBA::tk_##type: {\ + CORBA::CT b = da->get_##type();\ + if (!newline) tab(""); ACE_DEBUG ((LM_DEBUG, str , b));\ +} break; + +void +DynAnyAnalyzer::analyze ( + DynamicAny::DynAny_ptr da, + CORBA::Boolean newline) +{ + CORBA::TypeCode_var tc (da->type ()); + CORBA::TCKind kind (tc->kind ()); + CORBA::TypeCode_var + dup (CORBA::TypeCode::_duplicate (tc.in ())); + + // strip aliases + while (CORBA::tk_alias == kind) + { + dup = dup->content_type (); + kind = dup->kind (); + } + + switch (kind) + { + case CORBA::tk_value_box: + { + DynamicAny::DynValueBox_var + box (DynamicAny::DynValueBox::_narrow (da)); + + if (!newline) + { + tab (""); + } + if (box->is_null ()) + { + ACE_DEBUG ((LM_DEBUG, "{NULL} ")); + } + ACE_DEBUG ((LM_DEBUG, "ValueBox Type: %C \"%C\": ", + tc->name (), tc->id ()) ); + if (box->is_null ()) + { + ACE_DEBUG ((LM_DEBUG, "\n")); + } + else + { + DynamicAny::DynAny_var + cc (box->current_component ()); + this->analyze (cc.in (), true); + } + } + break; // end tk_valuebox + + case CORBA::tk_value: + { + DynamicAny::DynValue_var + dvt (DynamicAny::DynValue::_narrow (da)); + + if (!newline) + { + tab (""); + } + if (dvt->is_null ()) + { + ACE_DEBUG ((LM_DEBUG, "{NULL} ")); + } + + BaseTypesList_t base_types; + get_base_types (tc, base_types); + + for (CORBA::ULong i= 0u; i < base_types.size(); ++i) + { + if (i) + { + tab (": "); + } + else + { + ACE_DEBUG ((LM_DEBUG, "ValueType: ")); + } + + switch (base_types[i]->type_modifier ()) + { + case CORBA::VM_CUSTOM: + ACE_DEBUG ((LM_DEBUG, "Custom ")); + break; + + case CORBA::VM_ABSTRACT: + ACE_DEBUG ((LM_DEBUG, "Abstract ")); + break; + + case CORBA::VM_TRUNCATABLE: + ACE_DEBUG ((LM_DEBUG, "Truncatable ")); + break; + + default: + break; + } + + ACE_DEBUG ((LM_DEBUG, "%C \"%C\"\n", + base_types[i]->name (), + base_types[i]->id () )); + ++level_; + } + level_ -= base_types.size(); + + if (!(dvt->is_null ())) + { + CORBA::ULong member_number = 0u; + ++level_; + if (da->seek (0)) do + { + DynamicAny::DynAny_var + cc (dvt->current_component ()); + DynamicAny::FieldName_var + fn (dvt->current_member_name ()); + CORBA::ULong sub_member_number = member_number; + const CORBA::TypeCode_ptr + base = get_correct_base_type ( + base_types, + sub_member_number); + const char *const visability = + ((CORBA::PRIVATE_MEMBER == + base->member_visibility (sub_member_number)) ? + "Private" : "Public "); + tab ("["); + ACE_DEBUG ((LM_DEBUG, "%03u] %C \"%C\": ", + ++member_number, visability, fn.in () )); + if (CORBA::is_nil (cc.in ())) + { + ACE_DEBUG ((LM_DEBUG, " {Null}\n")); + } + else + { + this->analyze (cc.in (), true); + } + } while (da->next ()); + else + { + tab("{Has No Members}\n"); + } + --level_; + } + } + break; // end tk_value + + case CORBA::tk_struct: + { + DynamicAny::DynStruct_var + ds (DynamicAny::DynStruct::_narrow (da)); + + if (newline) + { + ACE_DEBUG ((LM_DEBUG, "\n")); + } + tab ("Struct: "); + ACE_DEBUG ((LM_DEBUG, "%C \"%C\"", + tc->name (), tc->id () )); + if (da->seek (0)) + { + ACE_DEBUG ((LM_DEBUG, "\n")); + ++level_; + do + { + DynamicAny::DynAny_var + cc (ds->current_component ()); + DynamicAny::FieldName_var + fn (ds->current_member_name ()); + + tab ("Member = "); + ACE_DEBUG ((LM_DEBUG, "%C\n", fn.in ())); + if (!CORBA::is_nil (cc.in ())) + { + this->analyze (cc.in ()); + } + } while (da->next ()); + --level_; + } + else + { + ACE_DEBUG ((LM_DEBUG, " Null\n")); + } + } + break; // end tk_struct + + case CORBA::tk_union: + { + if (newline) + { + ACE_DEBUG ((LM_DEBUG, "\n")); + } + tab ("Union: "); + ACE_DEBUG ((LM_DEBUG, "%C \"%C\"", + tc->name (), tc->id () )); + DynamicAny::DynUnion_var + value (DynamicAny::DynUnion::_narrow (da)); + if (value->has_no_active_member ()) + { + ACE_DEBUG ((LM_DEBUG, " No Active member\n")); + } + else + { + ACE_DEBUG ((LM_DEBUG, "\n")); + DynamicAny::DynAny_var disc (value->member ()); + if (!CORBA::is_nil (disc.in ())) + { + ++level_; + this->analyze (disc.in ()); + --level_; + } + } + } + break; // end tk_union + + case CORBA::tk_enum: + { + DynamicAny::DynEnum_var + value (DynamicAny::DynEnum::_narrow (da)); + + if (newline) + { + ACE_DEBUG ((LM_DEBUG, "\n")); + } + tab ("Enum: "); + ACE_DEBUG ((LM_DEBUG, "%C \"%C\"", + tc->name (), tc->id () )); + CORBA::String_var s (value->get_as_string ()); + ACE_DEBUG ((LM_DEBUG, " value %C\n", s.in())); + } + break; // end tk_enum + + case CORBA::tk_sequence: + { + if (TAO_DynCommon::is_basic_type_seq (tc.in ())) + { + if (newline) ACE_DEBUG ((LM_DEBUG, "\n")); + this->analyze_basic_seq (dup.in (), da); + } + else + { + DynamicAny::DynSequence_var + ds (DynamicAny::DynSequence::_narrow (da)); + + int i = 0; + if (newline) + { + ACE_DEBUG ((LM_DEBUG, "\n")); + } + tab ("Sequence:\n"); + if (ds->seek (0)) + { + ++level_; + do + { + tab (""); + ACE_DEBUG ((LM_DEBUG, "[%03d]\n", i)); + DynamicAny::DynAny_var + cc (ds->current_component ()); + if (!CORBA::is_nil (cc.in ())) + { + analyze (cc.in ()); + } + ++i; + } while (da->next ()); + --level_; + } + } + } + break; // end tk_sequence + + case CORBA::tk_array: + { + if (newline) + { + ACE_DEBUG ((LM_DEBUG, "\n")); + } + tab ("Array\n"); + --level_; + + CORBA::ULong const len = dup->length (); + for (CORBA::ULong i = 0u; i < len; ++i) + { + tab (""); + ACE_DEBUG ((LM_DEBUG, "[%03d]\n", i)); + DynamicAny::DynAny_var + cc (da->current_component()); + if (!CORBA::is_nil (cc.in ())) + { + analyze (cc.in ()); + } + da->next (); + } + --level_; + } + break; // end tk_array + + case CORBA::tk_any: + { + tab ("Any\n"); + CORBA::Any_var any (da->get_any ()); + DynamicAny::DynAny_var + dynany (DynAny (any.in ())); + if (!CORBA::is_nil (dynany.in ())) + { + ++level_; + this->analyze (dynany.in ()); + --level_; + } + } + break; // end tk_any + + CASEE (boolean, Boolean, "(bool) = %d\n"); + CASEE (short, Short, "(short) = %hd\n"); + CASEE (ushort, UShort, "(unsigned short) = %hu\n"); + CASEE (long, Long, "(long) = %d\n"); + CASEE (ulong, ULong, "(unsigned long) = %u\n"); + CASEE (longlong, LongLong, "(longlong) %Ld\n"); + CASEE (ulonglong, ULongLong, "(unsigned longlong) %Lu\n"); + CASEE (char, Char, "(char) = %c\n"); + CASEE (float, Float, "(float) = %f\n"); + CASEE (double, Double, "(double) = %f\n"); + CASEE (octet, Octet, "(octet) = %c\n"); + + case CORBA::tk_string: + { + CORBA::String_var b (da->get_string ()); + if (!newline) + { + tab(""); + } + ACE_DEBUG ((LM_DEBUG, "(string) = \"%C\"\n", + b.in () )); + } + break; // end tk_string + + case CORBA::tk_TypeCode: + { + const CORBA::TCKind + kind =da->get_typecode ()->kind (); + if (!newline) + { + tab(""); + } + ACE_DEBUG ((LM_DEBUG, "(TypeCode) = %d\n", + static_cast (kind) )); + } + break; // end tk_TypeCode + + default: + { + const CORBA::TCKind + kind = tc->kind (); + if (newline) + { + ACE_DEBUG ((LM_DEBUG, "\n")); + } + tab ("***Unhandled*** TypeCode = "); + ACE_DEBUG ((LM_DEBUG, "%d\n", + static_cast (kind) )); + } + break; + } +} + +#define CASEBS(type,CT,str) case CORBA::tk_##type: {\ + CORBA::CT##Seq_var seq (da->get_##type##_seq ());\ + ++level_; CORBA::ULong len = seq->length ();\ + tab ("length = "); ACE_DEBUG ((LM_DEBUG, "%u\n", len));\ + for (CORBA::ULong i = 0; i < len; ++i) {\ + CORBA::CT b = seq[i];\ + tab (""); ACE_DEBUG ((LM_DEBUG, "[%3d] ", i));\ + ACE_DEBUG ((LM_DEBUG, str, b)); }\ + --level_;\ +} break; + +void +DynAnyAnalyzer::analyze_basic_seq ( + CORBA::TypeCode_ptr tc, + DynamicAny::DynAny_ptr da) +{ + CORBA::TypeCode_var ct (tc->content_type ()); + CORBA::TCKind tk = ct->kind (); + + tab ("BASIC Type Sequence - "); + switch (tk) + { + CASEBS (boolean, Boolean, "Value (bool) = %d\n"); + CASEBS (octet, Octet, "Value (octet) = %c\n"); + CASEBS (char, Char, "Value (char) = %c\n"); + CASEBS (wchar, WChar, "Value (wchar) = %u\n"); + CASEBS (short, Short, "Value (short) = %d\n"); + CASEBS (ushort, UShort, "Value (ushort) = %u\n"); + CASEBS (long, Long, "Value (long) = %d\n"); + CASEBS (ulong, ULong, "Value (ulong) = %u\n"); + CASEBS (longlong, LongLong, "Value (longlong) = %Ld\n"); + CASEBS (ulonglong, ULongLong, "Value (ulonglong) = %Lu\n"); + CASEBS (float, Float, "Value (float) = %f\n"); + CASEBS (double, Double, "Value (double) = %f\n"); + + case CORBA::tk_longdouble: + default: + ACE_DEBUG ((LM_DEBUG, + "***Unhandled*** TypeCode = %d\n", + static_cast (tk) )); + break; + } +} diff --git a/TAO/tests/DynValue_Test/Analyzer.h b/TAO/tests/DynValue_Test/Analyzer.h new file mode 100644 index 00000000000..c40fcf876fb --- /dev/null +++ b/TAO/tests/DynValue_Test/Analyzer.h @@ -0,0 +1,60 @@ +// $Id$ + +#ifndef INCLUDE_ANALYZER_H +#define INCLUDE_ANALYZER_H + +#include "ValueTypes_impl.h" +#include "tao/DynamicAny/DynAnyFactory.h" + +//============= class DynAnyAnalyzer ============ + +class DynAnyAnalyzer +{ +private: + unsigned int level_; + CORBA::ORB_var orb_; + DynamicAny::DynAnyFactory_var dany_fact_; + +public: + DynAnyAnalyzer (int argc, ACE_TCHAR *argv[]); + ~DynAnyAnalyzer (void) {orb_->destroy ();} + + DynamicAny::DynAny_ptr DynAny_NoTrunc (const CORBA::Any &); + DynamicAny::DynAny_ptr DynAny (const CORBA::Any &); + DynamicAny::DynAny_ptr DynAny (const CORBA::TypeCode_ptr &); + + void register_factory (CORBA::ValueFactoryBase_var factory); + + void analyze ( + DynamicAny::DynAny_ptr da, + CORBA::Boolean newline = false); + +private: + /// List of base types. + typedef ACE_Array_Base BaseTypesList_t; + + void tab (const char p[]) + { + for (unsigned int i = 0u; i < level_ ; ++i) + ACE_DEBUG ((LM_DEBUG, "..")); + ACE_DEBUG ((LM_DEBUG, "%C", p)); + } + + void analyze_basic_seq ( + CORBA::TypeCode_ptr tc, + DynamicAny::DynAny_ptr da); + + static void get_base_types ( + CORBA::TypeCode_ptr tc, + BaseTypesList_t &base_types, + CORBA::ULong *total_member_count = 0); + + /// Return the unaliased valuetype typecode that corresponds to + /// index (0..total_members-1) from the given hiarchical list of + /// the derived type and it basetypes. + static CORBA::TypeCode_ptr get_correct_base_type ( + const BaseTypesList_t &base_types, + CORBA::ULong &index); +}; + +#endif // INCLUDE_ANALYZER_H diff --git a/TAO/tests/DynValue_Test/DynValue_Test.idl b/TAO/tests/DynValue_Test/DynValue_Test.idl new file mode 100644 index 00000000000..185aadab761 --- /dev/null +++ b/TAO/tests/DynValue_Test/DynValue_Test.idl @@ -0,0 +1,36 @@ +// $Id$ + +module DynValue_Test +{ + abstract valuetype avt + { + void print (); + }; + + valuetype BaseValue : avt + { + public unsigned short Base_us1; + public unsigned short Base_us2; + }; + + valuetype BoxedLong long; + + valuetype NestedValue + { + public short Nested_s1; + public short Nested_s2; + }; + + valuetype NullValue + { + }; + + valuetype Trunc : truncatable BaseValue + { + public BoxedLong Trunc_bl; + public NestedValue Trunc_nested; + private NullValue Trunc_null1; + private NullValue Trunc_null2; + private NullValue Trunc_null3; + }; +}; diff --git a/TAO/tests/DynValue_Test/DynValue_Test.mpc b/TAO/tests/DynValue_Test/DynValue_Test.mpc new file mode 100644 index 00000000000..64b6c55fa37 --- /dev/null +++ b/TAO/tests/DynValue_Test/DynValue_Test.mpc @@ -0,0 +1,28 @@ +// $Id$ + +project(*IDL): dynamicany { + IDL_Files { + DynValue_Test.idl + idlflags += -SS + } + custom_only = 1 +} + + +project(DynValue_Test): dynamicany, typecodefactory { + exename = DynValue_Test + after += *IDL + Source_Files { + main.cpp + ValueTypes_impl.cpp + Analyzer.cpp + DynValue_TestC.cpp + } + Header_Files { + ValueTypes_impl.h + Analyzer.h + DynValue_TestC.h + } + IDL_Files { + } +} diff --git a/TAO/tests/DynValue_Test/ValueTypes_impl.cpp b/TAO/tests/DynValue_Test/ValueTypes_impl.cpp new file mode 100644 index 00000000000..d8fca9ed7dd --- /dev/null +++ b/TAO/tests/DynValue_Test/ValueTypes_impl.cpp @@ -0,0 +1,152 @@ +// $Id$ + +#include "ValueTypes_impl.h" +#include "tao/AnyTypeCode/TypeCode.h" + +//============= "BaseValue" Value Type implimentation ======= + +BaseValue_impl::~BaseValue_impl () +{ +} + +CORBA::ValueBase * +BaseValue_impl::_copy_value () +{ + CORBA::ValueBase *vb= 0; + ACE_NEW_THROW_EX ( + vb, + BaseValue_impl (this->Base_us1 (), this->Base_us2 ()), + CORBA::NO_MEMORY ()); + return vb; +} + +void +BaseValue_impl::print () +{ + ACE_DEBUG ((LM_DEBUG, "BaseValue (Base_us1 %u, Base_us2 %u)\n", + this->Base_us1 (), + this->Base_us2 () )); +} + +const char * BaseValue_Factory::id () const +{ + return DynValue_Test::_tc_BaseValue->id (); +} + +CORBA::ValueBase * BaseValue_Factory::create_for_unmarshal () +{ + CORBA::ValueBase *vb= 0; + ACE_NEW_THROW_EX (vb, BaseValue_impl (), CORBA::NO_MEMORY ()); + return vb; +} + +//============= "Nested" Value Type implimentation ======= + +NestedValue_impl::~NestedValue_impl () +{ +} + +CORBA::ValueBase * NestedValue_impl::_copy_value () +{ + CORBA::ValueBase *vb= 0; + ACE_NEW_THROW_EX ( + vb, + NestedValue_impl (this->Nested_s1 (), this->Nested_s2 ()), + CORBA::NO_MEMORY ()); + return vb; +} + +const char * NestedValue_Factory::id () const +{ + return DynValue_Test::_tc_NestedValue->id (); +} + +CORBA::ValueBase * NestedValue_Factory::create_for_unmarshal () +{ + CORBA::ValueBase *vb= 0; + ACE_NEW_THROW_EX (vb, NestedValue_impl (), CORBA::NO_MEMORY ()); + return vb; +} + +//============= "Null" Value Type implimentation ======= + +NullValue_impl::~NullValue_impl () +{ +} + +CORBA::ValueBase * NullValue_impl::_copy_value () +{ + CORBA::ValueBase *vb= 0; + ACE_NEW_THROW_EX (vb, NullValue_impl (), CORBA::NO_MEMORY ()); + return vb; +} + +const char * NullValue_Factory::id () const +{ + return DynValue_Test::_tc_NullValue->id (); +} + +CORBA::ValueBase * NullValue_Factory::create_for_unmarshal () +{ + CORBA::ValueBase *vb= 0; + ACE_NEW_THROW_EX (vb, NullValue_impl (), CORBA::NO_MEMORY ()); + return vb; +} + +//============= "Trunc" Value Type implimentation ======= + +Trunc_impl::~Trunc_impl () +{ +} + +CORBA::ValueBase * Trunc_impl::_copy_value () +{ + CORBA::ValueBase *vb= 0; + ACE_NEW_THROW_EX ( + vb, + Trunc_impl ( + this->Base_us1(), + this->Base_us2(), + dynamic_cast + (this->Trunc_bl ()->_copy_value()), + dynamic_cast + (this->Trunc_nested ()->_copy_value()), + dynamic_cast + (this->Trunc_null1 ()->_copy_value()), + dynamic_cast + (this->Trunc_null2 ()->_copy_value()), + dynamic_cast + (this->Trunc_null3 ()->_copy_value()) ), + CORBA::NO_MEMORY ()); + return vb; +} + +void +Trunc_impl::print () +{ + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("BaseValue (Base_us1 %u, Base_us2 %u) ") + ACE_TEXT ("Trunc (Trunc_bl (long %d), ") + ACE_TEXT ("Trunc_nested (Nested_s1 %d, Nested_s2 %d), ") + ACE_TEXT ("3xTrunc_null (%x %x %x))\n"), + this->Base_us1 (), + this->Base_us2 (), + this->Trunc_bl()->_value (), + this->Trunc_nested()->Nested_s1 (), + this->Trunc_nested()->Nested_s2 (), + (void *) this->Trunc_null1(), + (void *) this->Trunc_null2(), + (void *) this->Trunc_null3() )); +} + +const char * Trunc_Factory::id () const +{ + return DynValue_Test::_tc_Trunc->id (); +} + +CORBA::ValueBase * Trunc_Factory::create_for_unmarshal () +{ + CORBA::ValueBase *vb= 0; + ACE_NEW_THROW_EX (vb, Trunc_impl (), CORBA::NO_MEMORY ()); + return vb; +} diff --git a/TAO/tests/DynValue_Test/ValueTypes_impl.h b/TAO/tests/DynValue_Test/ValueTypes_impl.h new file mode 100644 index 00000000000..185b6926074 --- /dev/null +++ b/TAO/tests/DynValue_Test/ValueTypes_impl.h @@ -0,0 +1,111 @@ +// $Id$ + +#ifndef INCLUDE_VALUETYPE_IMPL_H +#define INCLUDE_VALUETYPE_IMPL_H + +#include "DynValue_TestC.h" + +//============= Factory_id helper mix-in class =========== + +class factory_id : public virtual CORBA::ValueFactoryBase +{ +public: + virtual const char * id () const = 0; +}; + +//============= "BaseValue" Value Type implimentation ======= + +class BaseValue_impl : public virtual OBV_DynValue_Test::BaseValue, + public virtual CORBA::DefaultValueRefCountBase +{ +public: + BaseValue_impl () {} + BaseValue_impl (CORBA::UShort us1, CORBA::UShort us2) + :BaseValue (us1,us2) {} + virtual ~BaseValue_impl (); + virtual CORBA::ValueBase * _copy_value (void); + virtual void print (); +}; + +class BaseValue_Factory : public factory_id +{ +public: + const char * id () const; + virtual CORBA::ValueBase * create_for_unmarshal (); +}; + +//============= "Nested" Value Type implimentation ======= + +class NestedValue_impl : public virtual OBV_DynValue_Test::NestedValue, + public virtual CORBA::DefaultValueRefCountBase +{ +public: + NestedValue_impl () {} + NestedValue_impl (CORBA::Short s1, CORBA::Short s2) + :NestedValue (s1,s2) {} + virtual ~NestedValue_impl (); + virtual CORBA::ValueBase * _copy_value (void); +}; + +class NestedValue_Factory : public factory_id +{ +public: + const char * id () const; + virtual CORBA::ValueBase * create_for_unmarshal (); +}; + +//============= "Null" Value Type implimentation ======= + +class NullValue_impl : public virtual OBV_DynValue_Test::NullValue, + public virtual CORBA::DefaultValueRefCountBase +{ +public: + NullValue_impl () {} + virtual ~NullValue_impl (); + virtual CORBA::ValueBase * _copy_value (void); +}; + +class NullValue_Factory : public factory_id +{ +public: + const char * id () const; + virtual CORBA::ValueBase * create_for_unmarshal (); +}; + +//============= "Trunc" Value Type implimentation ======= + +class Trunc_impl : public virtual OBV_DynValue_Test::Trunc, + public virtual CORBA::DefaultValueRefCountBase +{ +public: + Trunc_impl () {} + Trunc_impl ( + CORBA::UShort us1, + CORBA::UShort us2, + DynValue_Test::BoxedLong *bl, + NestedValue_impl *nv1, + NullValue_impl *nv2, + NullValue_impl *nv3, + NullValue_impl *nv4) + { + this->Base_us1 (us1); + this->Base_us2 (us2); + this->Trunc_bl (bl); + this->Trunc_nested (nv1); + this->Trunc_null1 (nv2); + this->Trunc_null2 (nv3); + this->Trunc_null3 (nv4); + } + virtual ~Trunc_impl (); + virtual CORBA::ValueBase * _copy_value (); + virtual void print (); +}; + +class Trunc_Factory : public factory_id +{ +public: + const char * id () const; + virtual CORBA::ValueBase * create_for_unmarshal (); +}; + +#endif // INCLUDE_VALUETYPE_IMPL_H diff --git a/TAO/tests/DynValue_Test/main.cpp b/TAO/tests/DynValue_Test/main.cpp new file mode 100644 index 00000000000..79936879319 --- /dev/null +++ b/TAO/tests/DynValue_Test/main.cpp @@ -0,0 +1,1231 @@ +// $Id$ + +#include "Analyzer.h" + +//============= Test main() ============ +int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) +{ + try + { + DynAnyAnalyzer analyzer (argc, argv); + + //////////////////////////////////////////// + // DynValue_Test::BoxedLong + //////////////////////////////////////////// + + const CORBA::Long l1= -157; + + ACE_DEBUG ((LM_DEBUG, + "%N:%l Creating DynValue_Test::BoxedLong\n")); + DynValue_Test::BoxedLong *p_myBoxedLong =0; + ACE_NEW_THROW_EX ( + p_myBoxedLong, + DynValue_Test::BoxedLong (l1), + CORBA::NO_MEMORY ()); + DynValue_Test::BoxedLong_var myBoxedLong (p_myBoxedLong); + ACE_DEBUG ((LM_DEBUG, + "..%N:%l checking value, long is %d\n", + myBoxedLong->_value () )); + if (l1 != myBoxedLong->_value ()) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED should have been %d\n", l1)); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Inserting into an any\n")); + CORBA::Any myAny; + myAny <<= myBoxedLong.in (); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Extracting from an any\n")); + DynValue_Test::BoxedLong + *myBoxedLongExtracted = + reinterpret_cast (9); + if (!(myAny >>= myBoxedLongExtracted)) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED extraction\n")); + return 1; + } + if (!myBoxedLongExtracted) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED Null pointer extracted\n")); + return 1; + } + if (reinterpret_cast (9) + == myBoxedLongExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED pointer NOT extracted\n")); + return 1; + } + ACE_DEBUG ((LM_DEBUG, + "..%N:%l checking value, long is %d\n", + myBoxedLongExtracted->_value () )); + if (l1 != myBoxedLongExtracted->_value ()) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED should have been %d\n", l1)); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Creating dynamic any from any\n")); + DynamicAny::DynAny_var dany_boxed (analyzer.DynAny (myAny)); + analyzer.analyze (dany_boxed.in ()); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Testing dynamic any for non-null\n")); + DynamicAny::DynValueCommon *dvc = + dynamic_cast (dany_boxed.in ()); + if (!dvc) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILURE can not obtain DynamicAny::DynValueCommon *\n")); + return 1; + } + if (dvc->is_null ()) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED this dynamic any is NULL!\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Creating dynamic any from IDL generated typecode\n")); + DynamicAny::DynAny_var + dany (analyzer.DynAny (DynValue_Test::_tc_BoxedLong)); + analyzer.analyze (dany.in ()); + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Testing typecode generated dynamic any for null\n")); + dvc= dynamic_cast (dany.in ()); + if (!dvc) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILURE can not obtain DynamicAny::DynValueCommon\n")); + return 1; + } + if (!(dvc->is_null ())) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED this dynamic any has a value!\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Testing for inequality with original dyanamic any\n")); + if (dany->equal (dany_boxed.in ())) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED they test equal before setting shorts\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Setting to value and test for inequality with original dyanamic any\n")); + dvc->set_to_value (); + analyzer.analyze (dany.in ()); + if (dany->equal (dany_boxed.in ())) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED they test equal before setting long\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Setting the long of the typecode generated dynamic any\n")); + dany->insert_long (l1); + analyzer.analyze (dany.in ()); + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Testing for equality with original dyanamic any\n")); + if (!(dany->equal (dany_boxed.in ()))) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED they test unequal after setting long\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Setting typecode dynamic any back to NULL\n")); + dvc->set_to_null (); + analyzer.analyze (dany.in ()); + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Setting the original dynamic any to NULL object\n")); + dvc= dynamic_cast (dany_boxed.in ()); + if (!dvc) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILURE can not obtain DynamicAny::DynValueCommon *\n")); + return 1; + } + dvc->set_to_null (); + analyzer.analyze (dany_boxed.in ()); + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Testing for equality with typecode dyanamic any\n")); + if (!(dany->equal (dany_boxed.in ()))) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED they test unequal!\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Converting from NULL dynamic any back to any\n")); + CORBA::Any_var myAny_var (dany_boxed->to_any ()); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Extracting from this any\n")); + myBoxedLongExtracted= + reinterpret_cast (9); + if (!(myAny_var.in () >>= myBoxedLongExtracted)) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED extraction\n")); + return 1; + } + if (reinterpret_cast (9) + == myBoxedLongExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED pointer NOT extracted\n")); + return 1; + } + if (myBoxedLongExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED non-null pointer extracted\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Setting the dynamic any to VALUE object\n")); + dvc->set_to_value (); + analyzer.analyze (dany_boxed.in ()); + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Resetting Typecode dynamic any from original any\n")); + dany->from_any (myAny); + analyzer.analyze (dany.in ()); + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Testing for equality with original dyanamic any\n")); + if (!(dany->equal (dany_boxed.in ()))) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED they test unequal!\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Converting from dynamic any back to any\n")); + myAny_var = dany_boxed->to_any (); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Extracting from this any\n")); + myBoxedLongExtracted= + reinterpret_cast (9); + if (!(myAny_var.in () >>= myBoxedLongExtracted)) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED extraction\n")); + return 1; + } + if (!myBoxedLongExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED null pointer extracted\n")); + return 1; + } + if (reinterpret_cast (9) + == myBoxedLongExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED pointer NOT extracted\n")); + return 1; + } + ACE_DEBUG ((LM_DEBUG, + "..%N:%l checking value, long is %d\n", + myBoxedLongExtracted->_value () )); + if (l1 != myBoxedLongExtracted->_value ()) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED should have been %d\n", l1)); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Attempting to get_long from dynamic any\n")); + CORBA::Long myLongExtracted = dany_boxed->get_long (); + ACE_DEBUG ((LM_DEBUG, + "..%N:%l checking value, long is %d\n", + myLongExtracted )); + if (l1 != myLongExtracted) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED should have been %d\n", l1)); + return 1; + } + + //////////////////////////////////////////// + // DynValue_Test::NestedValue + //////////////////////////////////////////// + + const CORBA::Short s1= -17; + const CORBA::Short s2= -23; + + ACE_DEBUG ((LM_DEBUG, + "\n%N:%l Creating DynValue_Test::NestedValue\n")); + DynValue_Test::NestedValue *p_myNestedValue =0; + ACE_NEW_THROW_EX ( + p_myNestedValue, + NestedValue_impl(s1, s2), + CORBA::NO_MEMORY ()); + DynValue_Test::NestedValue_var myNestedValue (p_myNestedValue); + ACE_DEBUG ((LM_DEBUG, + "..%N:%l checking value, shorts are %hd, %hd\n", + myNestedValue->Nested_s1 (), + myNestedValue->Nested_s2 () )); + if (s1 != myNestedValue->Nested_s1 () || + s2 != myNestedValue->Nested_s2 ()) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED should have been %hd, %hd\n", + s1, s2)); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Inserting into an any\n")); + myAny <<= myNestedValue.in (); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Extracting from an any\n")); + DynValue_Test::NestedValue::_ptr_type + myNestedValueExtracted = + reinterpret_cast (9); + if (!(myAny >>= myNestedValueExtracted)) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED extraction\n")); + return 1; + } + if (!myNestedValueExtracted) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED Null pointer extracted\n")); + return 1; + } + if (reinterpret_cast (9) + == myNestedValueExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED pointer NOT extracted\n")); + return 1; + } + ACE_DEBUG ((LM_DEBUG, "..%N:%l checking value, shorts are %hd, %hd\n", + myNestedValueExtracted->Nested_s1 (), + myNestedValueExtracted->Nested_s2 ())); + if (s1 != myNestedValueExtracted->Nested_s1 () || + s2 != myNestedValueExtracted->Nested_s2 () ) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED should have been %hd, %hd\n", s1, s2)); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Creating dynamic any from any\n")); + DynamicAny::DynAny_var dany_nested = analyzer.DynAny (myAny); + analyzer.analyze (dany_nested.in ()); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Testing dynamic any for non-null\n")); + dvc = dynamic_cast + (dany_nested.in ()); + if (!dvc) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILURE can not obtain DynamicAny::DynValueCommon *\n")); + return 1; + } + if (dvc->is_null ()) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED this dynamic any is NULL!\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Creating dynamic any from IDL generated typecode\n")); + dany = analyzer.DynAny (DynValue_Test::_tc_NestedValue); + analyzer.analyze (dany.in ()); + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Testing typecode generated dynamic any for null\n")); + dvc= dynamic_cast (dany.in ()); + if (!dvc) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILURE can not obtain DynamicAny::DynValueCommon\n")); + return 1; + } + if (!(dvc->is_null ())) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED this dynamic any has a value!\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Testing for inequality with original dyanamic any\n")); + if (dany->equal (dany_nested.in ())) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED they test equal before setting shorts\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Setting to value and test for inequality with original dyanamic any\n")); + dvc->set_to_value (); + analyzer.analyze (dany.in ()); + if (dany->equal (dany_nested.in ())) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED they test equal before setting shorts\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Setting the shorts of the typecode generated dynamic any\n")); + dany->rewind (); + dany->insert_short (s1); + if (!(dany->next ())) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED to move on to second short\n")); + return 1; + } + dany->insert_short (s2); + analyzer.analyze (dany.in ()); + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Testing for equality with original dyanamic any\n")); + if (!(dany->equal (dany_nested.in ()))) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED they test unequal after setting shorts\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Setting typecode dynamic any back to NULL\n")); + dvc->set_to_null (); + analyzer.analyze (dany.in ()); + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Setting the original dynamic any to NULL object\n")); + dvc= dynamic_cast (dany_nested.in ()); + if (!dvc) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILURE can not obtain DynamicAny::DynValueCommon *\n")); + return 1; + } + dvc->set_to_null (); + analyzer.analyze (dany_nested.in ()); + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Testing for equality with typecode dyanamic any\n")); + if (!(dany->equal (dany_nested.in ()))) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED they test unequal!\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Converting from NULL dynamic any back to any\n")); + myAny_var = dany_nested->to_any (); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Extracting from this any\n")); + myNestedValueExtracted= + reinterpret_cast (9); + if (!(myAny_var.in () >>= myNestedValueExtracted)) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED extraction\n")); + return 1; + } + if (reinterpret_cast (9) + == myNestedValueExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED pointer NOT extracted\n")); + return 1; + } + if (myNestedValueExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED non-null pointer extracted\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Setting the dynamic any to VALUE object\n")); + dvc->set_to_value (); + analyzer.analyze (dany_nested.in ()); + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Resetting Typecode dynamic any from original any\n")); + dany->from_any (myAny); + analyzer.analyze (dany.in ()); + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Testing for equality with original dyanamic any\n")); + if (!(dany->equal (dany_nested.in ()))) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED they test unequal!\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Converting from dynamic any back to any\n")); + myAny_var = dany_nested->to_any (); + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Attempting to extract from this any (without factory)\n")); + myNestedValueExtracted= + reinterpret_cast (9); + if (myAny_var.in () >>= myNestedValueExtracted) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED the extraction occured without factory\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Attempting to get_val from dynamic any (without factory)\n")); + try + { + myNestedValueExtracted= + dynamic_cast ( + dany_nested->get_val ()); + if (myNestedValueExtracted) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED get_val successful without factory\n")); + return 1; + } + } + catch (const CORBA::MARSHAL &) + { + // Expected with no factory registered + } + + CORBA::ValueFactoryBase *vf= 0; + ACE_NEW_THROW_EX (vf, NestedValue_Factory, CORBA::NO_MEMORY ()); + analyzer.register_factory (vf); + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Extracting from this any (now with factory)\n")); + if (!(myAny_var.in () >>= myNestedValueExtracted)) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED the extraction\n")); + return 1; + } + if (!myNestedValueExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED Null pointer extracted\n")); + return 1; + } + if (reinterpret_cast (9) + == myNestedValueExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED pointer NOT extracted\n")); + return 1; + } + ACE_DEBUG ((LM_DEBUG, "..%N:%l checking value, shorts are %hd, %hd\n", + myNestedValueExtracted->Nested_s1 (), + myNestedValueExtracted->Nested_s2 ())); + if (s1 != myNestedValueExtracted->Nested_s1 () || + s2 != myNestedValueExtracted->Nested_s2 () ) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED should have been %hd, %hd\n", s1, s2)); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Attempting to get_val from dynamic any (now with factory)\n")); + myNestedValueExtracted= + dynamic_cast ( + dany_nested->get_val ()); + if (!myNestedValueExtracted) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED get_val unsuccessful even with factory\n")); + return 1; + } + ACE_DEBUG ((LM_DEBUG, "..%N:%l checking value, shorts are %hd, %hd\n", + myNestedValueExtracted->Nested_s1 (), + myNestedValueExtracted->Nested_s2 ())); + if (s1 != myNestedValueExtracted->Nested_s1 () || + s2 != myNestedValueExtracted->Nested_s2 () ) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED should have been %hd, %hd\n", s1, s2)); + return 1; + } + myNestedValueExtracted->_remove_ref (); + + //////////////////////////////////////////// + // DynValue_Test::NullValue + //////////////////////////////////////////// + + ACE_DEBUG ((LM_DEBUG, "\n%N:%l Creating DynValue_Test::NullValue\n")); + DynValue_Test::NullValue *p_myNullValue =0; + ACE_NEW_THROW_EX (p_myNullValue, NullValue_impl, CORBA::NO_MEMORY ()); + DynValue_Test::NullValue_var myNullValue (p_myNullValue); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Inserting into an any\n")); + myAny <<= myNullValue.in (); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Extracting from an any\n")); + DynValue_Test::NullValue::_ptr_type myNullValueExtracted= + reinterpret_cast (9); + if (!(myAny >>= myNullValueExtracted)) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED extraction\n")); + return 1; + } + if (!myNullValueExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED Null pointer extracted\n")); + return 1; + } + if (reinterpret_cast (9) + == myNullValueExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED pointer NOT extracted\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Creating dynamic any from any\n")); + DynamicAny::DynAny_var dany_null (analyzer.DynAny (myAny)); + analyzer.analyze (dany_null.in ()); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Testing dynamic any for non-null\n")); + dvc= dynamic_cast (dany_null.in ()); + if (!dvc) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILURE can not obtain DynamicAny::DynValueCommon *\n")); + return 1; + } + if (dvc->is_null ()) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED this dynamic any is NULL!\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Creating dynamic any from IDL generated typecode\n")); + dany = analyzer.DynAny (DynValue_Test::_tc_NullValue); + analyzer.analyze (dany.in ()); + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Testing typecode generated dynamic any for null\n")); + dvc= dynamic_cast (dany.in ()); + if (!dvc) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILURE can not obtain DynamicAny::DynValueCommon *\n")); + return 1; + } + if (!(dvc->is_null ())) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED this dynamic any has a value!\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Testing for inequality with original dyanamic any\n")); + if (dany->equal (dany_null.in ())) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILED they test equal before setting to a value\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, + "..%N:%l Setting to value and test for equality with original dyanamic any\n")); + dvc->set_to_value (); + analyzer.analyze (dany.in ()); + if (!(dany->equal (dany_null.in ()))) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED they test unequal\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Setting typecode dynamic any back to NULL\n")); + dvc->set_to_null (); + analyzer.analyze (dany.in ()); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Setting the original dynamic any to NULL object\n")); + dvc= dynamic_cast (dany_null.in ()); + if (!dvc) + { + ACE_DEBUG ((LM_DEBUG, + "..%N:%l FAILURE can not obtain DynamicAny::DynValueCommon\n")); + return 1; + } + dvc->set_to_null (); + analyzer.analyze (dany_null.in ()); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Testing for equality with typecode dyanamic any\n")); + if (!(dany->equal (dany_null.in ()))) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED they test unequal!\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Converting from NULL dynamic any back to any\n")); + myAny_var= dany_null->to_any (); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Extracting from this any\n")); + myNullValueExtracted= reinterpret_cast (9); + if (!(myAny_var.in () >>= myNullValueExtracted)) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED extraction\n")); + return 1; + } + if (reinterpret_cast (9) + == myNullValueExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED pointer NOT extracted\n")); + return 1; + } + if (myNullValueExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED non-null pointer extracted\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Setting the original dynamic any to VALUE object\n")); + dvc->set_to_value (); + analyzer.analyze (dany_null.in ()); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Resetting Typecode dynamic any from original any\n")); + dany->from_any (myAny); + analyzer.analyze (dany.in ()); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Testing for equality with original dyanamic any\n")); + if (!(dany->equal (dany_null.in ()))) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED they test unequal!\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Converting from dynamic any back to any\n")); + myAny_var = dany_null->to_any (); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Attempting to extract from this any (without factory)\n")); + myNullValueExtracted= reinterpret_cast (9); + if (myAny_var.in () >>= myNullValueExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED the extraction occured without factory\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Attempting to get_val from dynamic any (without factory)\n")); + try + { + myNullValueExtracted= dynamic_cast (dany_null->get_val ()); + if (myNullValueExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED get_val successful without factory\n")); + return 1; + } + } + catch (const CORBA::MARSHAL &) + { + // Expected with no factory registered + } + + ACE_NEW_THROW_EX (vf, NullValue_Factory, CORBA::NO_MEMORY ()); + analyzer.register_factory (vf); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Extracting from this any (now with factory)\n")); + if (!(myAny_var.in () >>= myNullValueExtracted)) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED the extraction\n")); + return 1; + } + if (!myNullValueExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED Null pointer extracted\n")); + return 1; + } + if (reinterpret_cast (9) == myNullValueExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED pointer NOT extracted\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Attempting to get_val from dynamic any (now with factory)\n")); + myNullValueExtracted= dynamic_cast (dany_null->get_val ()); + if (!myNullValueExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED get_val unsuccessful even with factory\n")); + return 1; + } + myNullValueExtracted->_remove_ref (); + + //////////////////////////////////////////// + // DynValue_Test::Trunc + //////////////////////////////////////////// + + const CORBA::Short us1= 12345; + const CORBA::Short us2= 321; + + DynValue_Test::NullValue *p_myNullValue2 =0; + ACE_NEW_THROW_EX (p_myNullValue2, NullValue_impl, CORBA::NO_MEMORY ()); + DynValue_Test::NullValue_var myNullValue2 (p_myNullValue2); + + ACE_DEBUG ((LM_DEBUG, "\n%N:%l Creating DynValue_Test::Trunc\n")); + DynValue_Test::Trunc *p_myTrunc =0; + ACE_NEW_THROW_EX ( + p_myTrunc, + Trunc_impl ( + us1, + us2, + myBoxedLong.in (), + dynamic_cast (myNestedValue.in ()), + dynamic_cast (myNullValue.in ()), + dynamic_cast (myNullValue.in ()), + dynamic_cast (myNullValue2.in ()) ), + CORBA::NO_MEMORY ()); + DynValue_Test::Trunc_var myTrunc (p_myTrunc); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l checking embedded values, ")); + myTrunc->print (); + if (us1 != myTrunc.in ()->Base_us1 () || + us2 != myTrunc.in ()->Base_us2 () || + l1 != myTrunc.in ()->Trunc_bl()->_value () || + s1 != myTrunc.in ()->Trunc_nested()->Nested_s1 () || + s2 != myTrunc.in ()->Trunc_nested()->Nested_s2 () ) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED should have been %u, %u, %d and %d, %d\n", us1, us2, l1, s1, s2)); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Inserting into an any\n")); + myAny <<= myTrunc.in (); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Extracting from an any\n")); + DynValue_Test::Trunc::_ptr_type myTruncExtracted= + reinterpret_cast (9); + if (!(myAny >>= myTruncExtracted)) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED extraction\n")); + return 1; + } + if (!myTruncExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED Null pointer extracted\n")); + return 1; + } + ACE_DEBUG ((LM_DEBUG, "..%N:%l checking embedded values, ")); + myTruncExtracted->print (); + if (us1 != myTruncExtracted->Base_us1 () || + us2 != myTruncExtracted->Base_us2 () || + l1 != myTruncExtracted->Trunc_bl()->_value () || + s1 != myTruncExtracted->Trunc_nested()->Nested_s1 () || + s2 != myTruncExtracted->Trunc_nested()->Nested_s2 () ) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED should have been %u, %u, %d and %d, %d\n", us1, us2, l1, s1, s2)); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Creating dynamic any from any\n")); + DynamicAny::DynAny_var dany_trunc (analyzer.DynAny (myAny)); + analyzer.analyze (dany_trunc.in ()); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Testing dynamic any for non-null\n")); + dvc= dynamic_cast (dany_trunc.in ()); + if (!dvc) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILURE can not obtain DynamicAny::DynValueCommon *\n")); + return 1; + } + if (dvc->is_null ()) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED this dynamic any is NULL!\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Creating dynamic any from IDL generated typecode DynValue_Test::_tc_Trunc\n")); + dany = analyzer.DynAny (DynValue_Test::_tc_Trunc); + analyzer.analyze (dany.in ()); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Testing typecode generated dynamic any for null\n")); + dvc= dynamic_cast (dany.in ()); + if (!dvc) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILURE can not obtain DynamicAny::DynValueCommon *\n")); + return 1; + } + if (!(dvc->is_null ())) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED this dynamic any has a value!\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Testing for inequality with original dyanamic any\n")); + if (dany->equal (dany_trunc.in ())) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED they test equal before setting shorts\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Setting to value and testing for inequality with original dyanamic any\n")); + dvc->set_to_value (); + analyzer.analyze (dany.in ()); + if (dany->equal (dany_trunc.in ())) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED they test equal before setting members\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Setting the members of the typecode generated dynamic any\n")); + dany->rewind (); + dany->insert_ushort (us1); + if (!(dany->next ())) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED to move on to 2nd member\n")); + return 1; + } + dany->insert_ushort (us2); + if (!(dany->next ())) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED to move on to 3rd member\n")); + return 1; + } + DynamicAny::DynValueCommon_var + dmem (dynamic_cast (dany->current_component ())); + if (!dmem.in()) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILURE can not obtain 3rd current_component ()\n")); + return 1; + } + dmem->set_to_value (); + dmem->insert_long (l1); + if (!(dany->next ())) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED to move on to 4th member\n")); + return 1; + } + dmem= dynamic_cast (dany->current_component ()); + if (!dmem.in()) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILURE can not obtain 4th current_component ()\n")); + return 1; + } + dmem->set_to_value (); + dmem->insert_val (myNestedValue.in ()); + if (!(dany->next ())) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED to move on to 5th member\n")); + return 1; + } + dmem= dynamic_cast (dany->current_component ()); + if (!dmem.in()) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILURE can not obtain 5th current_component ()\n")); + return 1; + } + dmem->set_to_value (); + dmem->insert_val (myNullValue.in ()); + if (!(dany->next ())) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED to move on to 6th member\n")); + return 1; + } + dmem= dynamic_cast (dany->current_component ()); + if (!dmem.in()) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILURE can not obtain 6th current_component ()\n")); + return 1; + } + dmem->set_to_value (); + dmem->insert_val (myNullValue.in ()); + if (!(dany->next ())) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED to move on to 7th member\n")); + return 1; + } + dmem= dynamic_cast (dany->current_component ()); + if (!dmem.in()) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILURE can not obtain 7th current_component ()\n")); + return 1; + } + dmem->set_to_value (); + dmem->insert_val (myNullValue2.in ()); + analyzer.analyze (dany.in ()); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Testing for equality with original dyanamic any\n")); + if (!(dany->equal (dany_trunc.in ()))) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED they test unequal after setting members\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Setting typecode dynamic any back to NULL\n")); + dvc->set_to_null (); + analyzer.analyze (dany.in ()); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Setting the original dynamic any to NULL object\n")); + dvc = dynamic_cast (dany_trunc.in ()); + if (!dvc) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILURE can not obtain DynamicAny::DynValueCommon *\n")); + return 1; + } + dvc->set_to_null (); + analyzer.analyze (dany_trunc.in ()); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Testing for equality with typecode dyanamic any\n")); + if (!(dany->equal (dany_trunc.in ()))) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED they test unequal!\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Converting from NULL dynamic any back to any\n")); + myAny_var= dany_trunc->to_any (); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Extracting from this any\n")); + myTruncExtracted= reinterpret_cast (9); + if (!(myAny_var.in () >>= myTruncExtracted)) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED extraction\n")); + return 1; + } + if (reinterpret_cast (9) == myTruncExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED pointer NOT extracted\n")); + return 1; + } + if (myTruncExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED non-null pointer extracted\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Setting the dynamic any to VALUE object\n")); + dvc->set_to_value (); + analyzer.analyze (dany_trunc.in ()); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Resetting Typecode dynamic any from original any\n")); + dany->from_any (myAny); + analyzer.analyze (dany.in ()); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Testing for equality with original dyanamic any\n")); + if (!(dany->equal (dany_trunc.in ()))) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED they test unequal!\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Converting from dynamic any back to any\n")); + myAny_var = dany_trunc->to_any (); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Attempting to extract from this any (without factory)\n")); + myTruncExtracted= reinterpret_cast (9); + if (myAny_var.in () >>= myTruncExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED the extraction occured without factory\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Attempting to get_val from dynamic any (without factory)\n")); + try + { + myTruncExtracted= dynamic_cast (dany_trunc->get_val ()); + if (myTruncExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED get_val successful without factory\n")); + return 1; + } + } + catch (const CORBA::MARSHAL &) + { + // Expected with no factory registered + } + + ACE_NEW_THROW_EX (vf, Trunc_Factory, CORBA::NO_MEMORY ()); + analyzer.register_factory (vf); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Extracting from this any (now with factory)\n")); + if (!(myAny_var.in () >>= myTruncExtracted)) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED extraction\n")); + return 1; + } + if (!myTruncExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED Null pointer extracted\n")); + return 1; + } + if (reinterpret_cast (9) == myTruncExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED pointer NOT extracted\n")); + return 1; + } + ACE_DEBUG ((LM_DEBUG, "..%N:%l checking embedded values, ")); + myTruncExtracted->print (); + if (us1 != myTruncExtracted->Base_us1 () || + us2 != myTruncExtracted->Base_us2 () || + l1 != myTruncExtracted->Trunc_bl()->_value () || + s1 != myTruncExtracted->Trunc_nested()->Nested_s1 () || + s2 != myTruncExtracted->Trunc_nested()->Nested_s2 () ) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED should have been %u, %u, %d and %d, %d\n", us1, us2, l1, s1, s2)); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Attempting to get_val from dynamic any (now with factory)\n")); + myTruncExtracted= dynamic_cast (dany_trunc->get_val ()); + if (!myTruncExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED get_val unsuccessful even with factory\n")); + return 1; + } + ACE_DEBUG ((LM_DEBUG, "..%N:%l checking embedded values, ")); + myTruncExtracted->print (); + if (us1 != myTruncExtracted->Base_us1 () || + us2 != myTruncExtracted->Base_us2 () || + l1 != myTruncExtracted->Trunc_bl()->_value () || + s1 != myTruncExtracted->Trunc_nested()->Nested_s1 () || + s2 != myTruncExtracted->Trunc_nested()->Nested_s2 () ) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED should have been %u, %u, %d and %d, %d\n", us1, us2, l1, s1, s2)); + return 1; + } + myTruncExtracted->_remove_ref (); + + /////////////////////////////////////////////////// + // DynValue_Test::Trunc -> DynValue_Test::BaseValue + /////////////////////////////////////////////////// + + ACE_DEBUG ((LM_DEBUG, "\n%N:%l Placing DynValue_Test::Trunc into DynValue_Test::BaseValue\n")); + DynValue_Test::BaseValue::_ptr_type p_myBaseValue = myTrunc.in (); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l checking values, ")); + p_myBaseValue->print (); + if (us1 != p_myBaseValue->Base_us1 () || + us2 != p_myBaseValue->Base_us2 () ) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED should have been %u and %u\n", us1, us2)); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Inserting into an any\n")); + CORBA::Any myAny_trunc; + myAny_trunc <<= p_myBaseValue; + ACE_DEBUG ((LM_DEBUG, "..%N:%l any reports type %C\n", myAny_trunc._tao_get_typecode ()->id ())); + myAny_trunc.type (DynValue_Test::_tc_BaseValue); + ACE_DEBUG ((LM_DEBUG, "..%N:%l any NOW reports type %C\n", myAny_trunc._tao_get_typecode ()->id ())); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Extracting BaseValue from an any\n")); + DynValue_Test::BaseValue::_ptr_type myBaseExtracted= + reinterpret_cast (9); + if (!(myAny_trunc >>= myBaseExtracted)) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED extraction\n")); + return 1; + } + if (!myBaseExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED Null pointer extracted\n")); + return 1; + } + ACE_DEBUG ((LM_DEBUG, "..%N:%l checking embedded values, ")); + myBaseExtracted->print (); + if (us1 != myBaseExtracted->Base_us1 () || + us2 != myBaseExtracted->Base_us2 () ) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED should have been %u and %u\n", us1, us2)); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Creating dynamic any from any\n")); + DynamicAny::DynAny_var dany_base (analyzer.DynAny (myAny_trunc)); + analyzer.analyze (dany_base.in ()); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Testing dynamic any for non-null\n")); + dvc= dynamic_cast (dany_base.in ()); + if (!dvc) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILURE can not obtain DynamicAny::DynValueCommon *\n")); + return 1; + } + if (dvc->is_null ()) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED this dynamic any is NULL!\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Converting from dynamic any back to any\n")); + myAny_var = dany_base->to_any (); + + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Attempting to extract from this any (without factory)\n")); + myBaseExtracted= reinterpret_cast (9); + if (myAny_var.in () >>= myBaseExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED the extraction occured without factory\n")); + return 1; + } + + ACE_NEW_THROW_EX (vf, BaseValue_Factory, CORBA::NO_MEMORY ()); + analyzer.register_factory (vf); + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Extracting from this any (now with factory)\n")); + if (!(myAny_var.in () >>= myBaseExtracted)) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED extraction\n")); + return 1; + } + if (!myBaseExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED Null pointer extracted\n")); + return 1; + } + if (reinterpret_cast (9) == myBaseExtracted) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED pointer NOT extracted\n")); + return 1; + } + ACE_DEBUG ((LM_DEBUG, "..%N:%l checking embedded values, ")); + myBaseExtracted->print (); + if (us1 != myBaseExtracted->Base_us1 () || + us2 != myBaseExtracted->Base_us2 () ) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED should have been %u, and %u\n", us1, us2)); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "..%N:%l Creating dynamic any from truncted any (no truncation allowed)\n")); + try + { + DynamicAny::DynAny_var dany_base (analyzer.DynAny_NoTrunc (myAny_trunc)); + ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED, obtained Dynamic any\n")); + analyzer.analyze (dany_base.in ()); + return 1; + } + catch (const DynamicAny::MustTruncate &) + { + ACE_DEBUG ((LM_DEBUG, "..%N:%l obtained MustTruncate as expected\n")); + } + + ACE_DEBUG ((LM_DEBUG, "\nAll tests passed\n")); + } + catch (const CORBA::TRANSIENT &) + { + ACE_DEBUG ((LM_INFO, "Transient\n")); + } + catch (const CORBA::COMM_FAILURE &) + { + ACE_DEBUG ((LM_INFO, "COMM_FAILURE\n")); + } + catch (const CORBA::Exception & ex) + { + ex._tao_print_exception ("Tests failed with CORBA exception:"); + return 1; + } + catch (...) + { + ACE_ERROR_RETURN ((LM_ERROR, "Test failed with NON-CORBA exception\n"), 1); + } + + return 0; +} diff --git a/TAO/tests/DynValue_Test/run_test.pl b/TAO/tests/DynValue_Test/run_test.pl new file mode 100755 index 00000000000..a678f06b12b --- /dev/null +++ b/TAO/tests/DynValue_Test/run_test.pl @@ -0,0 +1,22 @@ +eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' + & eval 'exec perl -S $0 $argv:q' + if 0; + +# $Id$ +# -*- perl -*- + +use lib "$ENV{ACE_ROOT}/bin"; +use PerlACE::TestTarget; + +my $server = PerlACE::TestTarget::create_target (1) || die "Create target 1 failed\n"; + +$SV = $server->CreateProcess ("DynValue_Test"); + +$test = $SV->SpawnWaitKill ($server->ProcessStartWaitInterval()+30); + +if ($test != 0) { + print STDERR "ERROR: test returned $test\n"; + exit 1; +} + +exit 0; -- cgit v1.2.1