ChangeLogTag: Wed Feb 29 16:36:300 UTC 2012 Simon Massey <simon dot massey at prismtech dot com>

Impliment DynValue, DynValueBox and DynValueCommon types

8 files changed, 2182 insertions, 0 deletions

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_id *> (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<int> (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<int> (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<int> (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<CORBA::TypeCode_var> 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<DynValue_Test::BoxedLong *>
+        (this->Trunc_bl ()->_copy_value()),
+      dynamic_cast<NestedValue_impl *>
+        (this->Trunc_nested ()->_copy_value()),
+      dynamic_cast<NullValue_impl   *>
+        (this->Trunc_null1 ()->_copy_value()),
+      dynamic_cast<NullValue_impl   *>
+        (this->Trunc_null2 ()->_copy_value()),
+      dynamic_cast<NullValue_impl   *>
+        (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<DynValue_Test::BoxedLong *> (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<DynValue_Test::BoxedLong *> (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<DynamicAny::DynValueCommon *> (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<DynamicAny::DynValueCommon *> (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<DynamicAny::DynValueCommon *> (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<DynValue_Test::BoxedLong *> (9);
+      if (!(myAny_var.in () >>= myBoxedLongExtracted))
+        {
+          ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED extraction\n"));
+          return 1;
+        }
+      if (reinterpret_cast<DynValue_Test::BoxedLong *> (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<DynValue_Test::BoxedLong *> (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<DynValue_Test::BoxedLong *> (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<DynValue_Test::NestedValue::_ptr_type> (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<DynValue_Test::NestedValue::_ptr_type> (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<DynamicAny::DynValueCommon *>
+              (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<DynamicAny::DynValueCommon *> (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<DynamicAny::DynValueCommon *> (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<DynValue_Test::NestedValue::_ptr_type> (9);
+      if (!(myAny_var.in () >>= myNestedValueExtracted))
+        {
+          ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED extraction\n"));
+          return 1;
+        }
+      if (reinterpret_cast<DynValue_Test::NestedValue::_ptr_type> (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<DynValue_Test::NestedValue::_ptr_type> (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<DynValue_Test::NestedValue*> (
+              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<DynValue_Test::NestedValue::_ptr_type> (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<DynValue_Test::NestedValue*> (
+          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<DynValue_Test::NullValue::_ptr_type> (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<DynValue_Test::NullValue::_ptr_type> (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<DynamicAny::DynValueCommon *> (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<DynamicAny::DynValueCommon *> (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<DynamicAny::DynValueCommon *> (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<DynValue_Test::NullValue::_ptr_type> (9);
+      if (!(myAny_var.in () >>= myNullValueExtracted))
+        {
+          ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED extraction\n"));
+          return 1;
+        }
+      if (reinterpret_cast<DynValue_Test::NullValue::_ptr_type> (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<DynValue_Test::NullValue::_ptr_type> (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<DynValue_Test::NullValue*> (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<DynValue_Test::NullValue::_ptr_type> (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<DynValue_Test::NullValue*> (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<NestedValue_impl *> (myNestedValue.in ()),
+          dynamic_cast<NullValue_impl *> (myNullValue.in ()),
+          dynamic_cast<NullValue_impl *> (myNullValue.in ()),
+          dynamic_cast<NullValue_impl *> (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<DynValue_Test::Trunc::_ptr_type> (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<DynamicAny::DynValueCommon *> (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<DynamicAny::DynValueCommon *> (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<DynamicAny::DynValueCommon *> (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<DynamicAny::DynValueCommon *> (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<DynamicAny::DynValueCommon *> (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<DynamicAny::DynValueCommon *> (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<DynamicAny::DynValueCommon *> (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<DynamicAny::DynValueCommon *> (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<DynValue_Test::Trunc::_ptr_type> (9);
+      if (!(myAny_var.in () >>= myTruncExtracted))
+        {
+          ACE_DEBUG ((LM_DEBUG, "..%N:%l FAILED extraction\n"));
+          return 1;
+        }
+      if (reinterpret_cast<DynValue_Test::Trunc::_ptr_type> (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<DynValue_Test::Trunc::_ptr_type> (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<DynValue_Test::Trunc *> (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<DynValue_Test::Trunc::_ptr_type> (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<DynValue_Test::Trunc*> (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<DynValue_Test::BaseValue::_ptr_type> (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<DynamicAny::DynValueCommon *> (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<DynValue_Test::BaseValue::_ptr_type> (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<DynValue_Test::BaseValue::_ptr_type> (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;