ChangeLogTag: Tue Jun 12 18:12:13 2001 Jeff Parsons <parsons@cs.wustl.edu>

9 files changed, 366 insertions, 170 deletions

diff --git a/TAO/tests/DynAny_Test/da_tests.idl b/TAO/tests/DynAny_Test/da_tests.idl
index 2afb3a9b13a..ad661c418e3 100644
--- a/TAO/tests/DynAny_Test/da_tests.idl
+++ b/TAO/tests/DynAny_Test/da_tests.idl
@@ -29,18 +29,16 @@ module DynAnyTests
     TE_ZEROTH,
     TE_FIRST,
     TE_SECOND,
-    TE_THIRD
+    TE_THIRD,
+    TE_FOURTH
   };
 
   union test_union switch (test_enum)
-    {
-    case TE_SECOND:
-      CORBA::TypeCode tc;
-    case TE_FIRST:
-      short s;
-    case TE_THIRD:
-      string str;
-    case TE_ZEROTH:
-      octet o;
-    };
+  {
+    case TE_SECOND: CORBA::TypeCode tc;
+    case TE_FOURTH: test_enum te;
+    default: short s;
+    case TE_THIRD: string str;
+    case TE_ZEROTH: octet o;
+  };
 };
diff --git a/TAO/tests/DynAny_Test/data.cpp b/TAO/tests/DynAny_Test/data.cpp
index 768c5dd4f0d..89a008bf0b0 100644
--- a/TAO/tests/DynAny_Test/data.cpp
+++ b/TAO/tests/DynAny_Test/data.cpp
@@ -95,8 +95,8 @@ Data::Data (CORBA::ORB_var orb)
 
       // Clean up after the POA
       root_poa->destroy (1,
-                        1,
-                        ACE_TRY_ENV);
+                         1,
+                         ACE_TRY_ENV);
 
       ACE_TRY_CHECK;
     }
diff --git a/TAO/tests/DynAny_Test/driver.cpp b/TAO/tests/DynAny_Test/driver.cpp
index 6f51ccaefce..ffe04da689a 100644
--- a/TAO/tests/DynAny_Test/driver.cpp
+++ b/TAO/tests/DynAny_Test/driver.cpp
@@ -202,32 +202,6 @@ Driver::run (void)
         break;
     }
 
-  ACE_TRY_NEW_ENV
-    {
-      CORBA::Object_var obj =
-        this->orb_->resolve_initial_references ("RootPOA",
-                                                ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      PortableServer::POA_var root_poa =
-        PortableServer::POA::_narrow (obj.in (),
-                                      ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-
-      root_poa->destroy (1,
-                         1,
-                         ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
-                           "Driver::run");
-
-      ACE_RE_THROW;
-    }
-  ACE_ENDTRY;
-
   return retstatus;
 }
 
diff --git a/TAO/tests/DynAny_Test/test_dynany.cpp b/TAO/tests/DynAny_Test/test_dynany.cpp
index a09a92e5c1a..875bca9c851 100644
--- a/TAO/tests/DynAny_Test/test_dynany.cpp
+++ b/TAO/tests/DynAny_Test/test_dynany.cpp
@@ -62,10 +62,13 @@ Test_DynAny::run_test (void)
         DynamicAny::DynAnyFactory::_narrow (factory_obj.in (),
                                             ACE_TRY_ENV);
       ACE_TRY_CHECK;
+
       if (CORBA::is_nil (dynany_factory.in ()))
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           "Nil dynamic any factory after narrow\n"),
-                          -1);
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "Nil dynamic any factory after narrow\n"),
+                            -1);
+        }
 
       CORBA::Any in1 (CORBA::_tc_double);
       DynamicAny::DynAny_var fa1 =
@@ -77,11 +80,16 @@ Test_DynAny::run_test (void)
       ACE_TRY_CHECK;
       CORBA::Double d_out = fa1->get_double (ACE_TRY_ENV);
       ACE_TRY_CHECK;
+
       if (d_out == data.m_double1)
-        ACE_DEBUG ((LM_DEBUG,
-                   "++ OK ++\n"));
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                     "++ OK ++\n"));
+        }
       else
-        ++this->error_count_;
+        {
+          ++this->error_count_;
+        }
 
       ACE_DEBUG ((LM_DEBUG,
                  "testing: constructor(TypeCode)/from_any/to_any\n"));
@@ -101,10 +109,14 @@ Test_DynAny::run_test (void)
       out_any1 >>= d_out;
 
       if (d_out == data.m_double1)
-        ACE_DEBUG ((LM_DEBUG,
-                   "++ OK ++\n"));
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                     "++ OK ++\n"));
+        }
       else
-        ++this->error_count_;
+        {
+          ++this->error_count_;
+        }
 
       fa1->destroy (ACE_TRY_ENV);
       ACE_TRY_CHECK;
@@ -128,12 +140,17 @@ Test_DynAny::run_test (void)
       ACE_TRY_CHECK;
       CORBA::TypeCode_var tc_out = fa2->get_typecode (ACE_TRY_ENV);
       ACE_TRY_CHECK;
+
       if (tc_out->equal (data.m_typecode1,
                          ACE_TRY_ENV))
-        ACE_DEBUG ((LM_DEBUG,
-                   "++ OK ++\n"));
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                     "++ OK ++\n"));
+        }
       else
-        ++this->error_count_;
+        {
+          ++this->error_count_;
+        }
 
       ACE_TRY_CHECK;
 
@@ -154,12 +171,19 @@ Test_DynAny::run_test (void)
       CORBA::TypeCode_ptr out_tc;
       out_any2 >>= out_tc;
 
-      if (out_tc->equal(data.m_typecode1,
-                        ACE_TRY_ENV))
-        ACE_DEBUG ((LM_DEBUG,
-                   "++ OK ++\n"));
+      CORBA::Boolean equal = out_tc->equal (data.m_typecode1,
+                                            ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+
+      if (equal)
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                     "++ OK ++\n"));
+        }
       else
-        ++this->error_count_;
+        {
+          ++this->error_count_;
+        }
 
       ACE_TRY_CHECK;
 
diff --git a/TAO/tests/DynAny_Test/test_dynarray.cpp b/TAO/tests/DynAny_Test/test_dynarray.cpp
index 1e6d2b90435..28bdeb70a8e 100644
--- a/TAO/tests/DynAny_Test/test_dynarray.cpp
+++ b/TAO/tests/DynAny_Test/test_dynarray.cpp
@@ -65,10 +65,13 @@ Test_DynArray::run_test (void)
         DynamicAny::DynAnyFactory::_narrow (factory_obj.in (),
                                             ACE_TRY_ENV);
       ACE_TRY_CHECK;
+
       if (CORBA::is_nil (dynany_factory.in ()))
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           "Nil dynamic any factory after narrow\n"),
-                          -1);
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "Nil dynamic any factory after narrow\n"),
+                            -1);
+        }
 
       CORBA::Any in_any1;
       in_any1 <<= ta;
@@ -93,11 +96,16 @@ Test_DynArray::run_test (void)
       ACE_TRY_CHECK;
       l_out1 = fa1->get_long (ACE_TRY_ENV);
       ACE_TRY_CHECK;
+
       if (l_out1 == data.m_long1)
-        ACE_DEBUG ((LM_DEBUG,
-                   "++ OK ++\n"));
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                     "++ OK ++\n"));
+        }
       else
-        ++this->error_count_;
+        {
+          ++this->error_count_;
+        }
 
       ACE_DEBUG ((LM_DEBUG,
                  "testing: constructor(TypeCode)/from_any/to_any\n"));
@@ -113,9 +121,11 @@ Test_DynArray::run_test (void)
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (ftc1.in ()))
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           "DynArray::_narrow() returned nil\n"),
-                          -1);
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "DynArray::_narrow() returned nil\n"),
+                            -1);
+        }
 
       ta[1] = data.m_long1;
       CORBA::Any in_any2;
@@ -129,10 +139,14 @@ Test_DynArray::run_test (void)
       out_any1.in () >>= ta_out;
 
       if (ta_out[(CORBA::ULong) 1] == data.m_long1)
-        ACE_DEBUG ((LM_DEBUG,
-                   "++ OK ++\n"));
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                     "++ OK ++\n"));
+        }
       else
-        ++this->error_count_;
+        {
+          ++this->error_count_;
+        }
 
       ACE_DEBUG ((LM_DEBUG,
                  "testing: set_elements/get_elements\n"));
@@ -146,19 +160,21 @@ Test_DynArray::run_test (void)
       ftc1->set_elements (as_in,
                           ACE_TRY_ENV);
       ACE_TRY_CHECK;
-      DynamicAny::AnySeq* as_out = ftc1->get_elements (ACE_TRY_ENV);
+      DynamicAny::AnySeq_var as_out = ftc1->get_elements (ACE_TRY_ENV);
       ACE_TRY_CHECK;
       CORBA_Any out_any2 = (*as_out)[1];
       CORBA::Long l_out2;
       out_any2 >>= l_out2;
+
       if (l_out2 == data.m_long1)
-        ACE_DEBUG ((LM_DEBUG,
-                   "++ OK ++\n"));
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                     "++ OK ++\n"));
+        }
       else
-        ++this->error_count_;
-
-      // Created with NEW
-      delete as_out;
+        {
+          ++this->error_count_;
+        }
 
       fa1->destroy (ACE_TRY_ENV);
       ACE_TRY_CHECK;
diff --git a/TAO/tests/DynAny_Test/test_dynenum.cpp b/TAO/tests/DynAny_Test/test_dynenum.cpp
index f544a2da169..b0b04b65927 100644
--- a/TAO/tests/DynAny_Test/test_dynenum.cpp
+++ b/TAO/tests/DynAny_Test/test_dynenum.cpp
@@ -43,12 +43,10 @@ Test_DynEnum::test_name (void) const
 int
 Test_DynEnum::run_test (void)
 {
-  DynAnyTests::test_enum te = DynAnyTests::TE_ZEROTH;
-
   ACE_TRY_NEW_ENV
     {
       ACE_DEBUG ((LM_DEBUG,
-                 "testing: constructor(Any)/value_as_ulong\n"));
+                 "testing: constructor(Any)/set_as_string/get_as_ulong\n"));
 
       CORBA::Object_var factory_obj =
         this->orb_->resolve_initial_references ("DynAnyFactory",
@@ -59,43 +57,59 @@ Test_DynEnum::run_test (void)
         DynamicAny::DynAnyFactory::_narrow (factory_obj.in (),
                                             ACE_TRY_ENV);
       ACE_TRY_CHECK;
+
       if (CORBA::is_nil (dynany_factory.in ()))
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           "Nil dynamic any factory after narrow\n"),
-                          -1);
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "Nil dynamic any factory after narrow\n"),
+                            -1);
+        }
 
+      DynAnyTests::test_enum te = DynAnyTests::TE_ZEROTH;
       CORBA_Any in_any1;
       in_any1 <<= te;
       DynamicAny::DynAny_var dp1 =
         dynany_factory->create_dyn_any (in_any1,
                                         ACE_TRY_ENV);
       ACE_TRY_CHECK;
-      DynamicAny::DynEnum_var de1 = DynamicAny::DynEnum::_narrow (dp1.in (),
-                                                      ACE_TRY_ENV);
+      DynamicAny::DynEnum_var de1 = 
+        DynamicAny::DynEnum::_narrow (dp1.in (),
+                                      ACE_TRY_ENV);
       ACE_TRY_CHECK;
-      de1->set_as_ulong (2, ACE_TRY_ENV);
+      de1->set_as_string ("TE_FIRST", 
+                          ACE_TRY_ENV);
       ACE_TRY_CHECK;
       CORBA::ULong ul_out1 = de1->get_as_ulong (ACE_TRY_ENV);
       ACE_TRY_CHECK;
-      if (ul_out1 == 2)
-        ACE_DEBUG ((LM_DEBUG,
-                   "++ OK ++\n"));
+
+      if (ul_out1 == 1)
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                     "++ OK ++\n"));
+        }
       else
-        ++this->error_count_;
+        {
+          ++this->error_count_;
+        }
 
       ACE_DEBUG ((LM_DEBUG,
-                 "testing: value_as_string\n"));
+                 "testing: set_as_ulong/get_as_string\n"));
 
-      de1->set_as_string ("TE_FIRST",
-                          ACE_TRY_ENV);
+      de1->set_as_ulong (3,
+                         ACE_TRY_ENV);
       ACE_TRY_CHECK;
       CORBA::String_var s = de1->get_as_string (ACE_TRY_ENV);
       ACE_TRY_CHECK;
-      if (!ACE_OS::strcmp (s.in (), "TE_FIRST"))
-        ACE_DEBUG ((LM_DEBUG,
-                   "++ OK ++\n"));
+
+      if (ACE_OS::strcmp (s.in (), "TE_THIRD") == 0)
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                     "++ OK ++\n"));
+        }
       else
-        ++this->error_count_;
+        {
+          ++this->error_count_;
+        }
 
 
       ACE_DEBUG ((LM_DEBUG,
@@ -112,23 +126,30 @@ Test_DynEnum::run_test (void)
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (de2.in ()))
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           "DynEnum::_narrow() returned nil\n"),
-                          -1);
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "DynEnum::_narrow() returned nil\n"),
+                            -1);
+        }
 
       CORBA_Any in_any2;
       in_any2 <<= DynAnyTests::TE_THIRD;
       de2->from_any (in_any2,
-                    ACE_TRY_ENV);
+                     ACE_TRY_ENV);
       ACE_TRY_CHECK;
       CORBA_Any_var out_any1 = de2->to_any (ACE_TRY_ENV);
       ACE_TRY_CHECK;
       out_any1.in () >>= te;
+
       if (te == DynAnyTests::TE_THIRD)
-        ACE_DEBUG ((LM_DEBUG,
-                   "++ OK ++\n"));
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                     "++ OK ++\n"));
+        }
       else
-        ++this->error_count_;
+        {
+          ++this->error_count_;
+        }
 
       de1->destroy (ACE_TRY_ENV);
       ACE_TRY_CHECK;
diff --git a/TAO/tests/DynAny_Test/test_dynsequence.cpp b/TAO/tests/DynAny_Test/test_dynsequence.cpp
index bda2f65e864..b6cd3922982 100644
--- a/TAO/tests/DynAny_Test/test_dynsequence.cpp
+++ b/TAO/tests/DynAny_Test/test_dynsequence.cpp
@@ -66,10 +66,13 @@ Test_DynSequence::run_test (void)
         DynamicAny::DynAnyFactory::_narrow (factory_obj.in (),
                                             ACE_TRY_ENV);
       ACE_TRY_CHECK;
+
       if (CORBA::is_nil (dynany_factory.in ()))
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           "Nil dynamic any factory after narrow\n"),
-                          -1);
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "Nil dynamic any factory after narrow\n"),
+                            -1);
+        }
 
       ts[0] = data.m_string2;
       ts[1] = data.m_string2;
@@ -95,11 +98,89 @@ Test_DynSequence::run_test (void)
       ACE_TRY_CHECK;
       CORBA::String_var out_str1 = fa1->get_string (ACE_TRY_ENV);
       ACE_TRY_CHECK;
+
       if (!ACE_OS::strcmp (out_str1.in (), data.m_string1))
-        ACE_DEBUG ((LM_DEBUG,
-                   "++ OK ++\n"));
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                     "++ OK ++\n"));
+        }
       else
-        ++this->error_count_;
+        {
+          ++this->error_count_;
+        }
+
+      ACE_DEBUG ((
+          LM_DEBUG,
+          "testing: set_elements_as_dyn_any/get_elements_as_dyn_any/equal\n"
+        ));
+
+      static const char *values[] = 
+      {
+        "zero",
+        "one",
+        "two"
+      };
+
+      CORBA::ULong length = 3;
+      DynamicAny::DynAnySeq *elem_ptr = 0;
+      ACE_NEW_RETURN (elem_ptr,
+                      DynamicAny::DynAnySeq (length),
+                      -1);
+      elem_ptr->length (length);
+      DynamicAny::DynAnySeq_var elements (elem_ptr);
+      CORBA_Any elem_any;
+      CORBA::ULong i;
+
+      for (i = 0; i < length; ++i)
+        {
+          elem_any <<= values[i];
+          elements[i] = dynany_factory->create_dyn_any (elem_any,
+                                                        ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+        }
+
+      fa1->set_elements_as_dyn_any (elements.in (),
+                                    ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+
+      DynamicAny::DynAnySeq_var out_elems = 
+        fa1->get_elements_as_dyn_any (ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+
+      if (out_elems->length () != 3)
+        {
+          ++this->error_count_;
+          return -1;
+        }
+
+      CORBA::String_var out_str;
+
+      for (i = 0; i < length; ++i)
+        {
+          out_str = out_elems[i]->get_string (ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+
+          CORBA::Boolean equal = 
+            out_elems[i]->equal (elements[i].in (),
+                                 ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+
+          if (!equal)
+            {
+              ++this->error_count_;
+            }
+
+          // To show that calling destroy() on a component does
+          // nothing, as required by the spec.
+          out_elems[i]->destroy (ACE_TRY_ENV);
+          ACE_TRY_CHECK;
+        }
+
+      if (this->error_count_ == 0)
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                      "++ OK ++\n"));
+        }
 
       ACE_DEBUG ((LM_DEBUG,
                  "testing: constructor(TypeCode)/from_any/to_any\n"));
@@ -115,9 +196,11 @@ Test_DynSequence::run_test (void)
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (ftc1.in ()))
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           "DynSequence::_narrow() returned nil\n"),
-                          -1);
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "DynSequence::_narrow() returned nil\n"),
+                            -1);
+        }
 
       ts[0] = CORBA::string_dup (data.m_string1);
       CORBA_Any in_any2;
@@ -125,24 +208,25 @@ Test_DynSequence::run_test (void)
       ftc1->from_any (in_any2,
                       ACE_TRY_ENV);
       ACE_TRY_CHECK;
-      CORBA::Any* out_any1 = ftc1->to_any (ACE_TRY_ENV);
+      CORBA::Any_var out_any1 = ftc1->to_any (ACE_TRY_ENV);
       ACE_TRY_CHECK;
       DynAnyTests::test_seq* ts_out;
       *out_any1 >>= ts_out;
+
       if (!ACE_OS::strcmp ((*ts_out)[0], data.m_string1))
-        ACE_DEBUG ((LM_DEBUG,
-                   "++ OK ++\n"));
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                     "++ OK ++\n"));
+        }
       else
-        ++this->error_count_;
-
-      // Created with NEW
-      delete out_any1;
-
+        {
+          ++this->error_count_;
+        }
 
       ACE_DEBUG ((LM_DEBUG,
                  "testing: length/set_elements/get_elements\n"));
 
-      CORBA::ULong length = ftc1->get_length (ACE_TRY_ENV);
+      length = ftc1->get_length (ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
       if (length != 2)
@@ -170,11 +254,17 @@ Test_DynSequence::run_test (void)
       CORBA_Any out_any2 = as_out[index];
       char* out_str2;
       out_any2 >>= CORBA::Any::to_string (out_str2, 0);
+
       if (ACE_OS::strcmp (out_str2, data.m_string1))
-        ++this->error_count_;
+        {
+          ++this->error_count_;
+        }
+
       if (this->error_count_ == 0)
-        ACE_DEBUG ((LM_DEBUG,
-                   "++ OK ++\n"));
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                     "++ OK ++\n"));
+        }
 
       fa1->destroy (ACE_TRY_ENV);
       ACE_TRY_CHECK;
diff --git a/TAO/tests/DynAny_Test/test_dynstruct.cpp b/TAO/tests/DynAny_Test/test_dynstruct.cpp
index ee801f56396..25ccd38df43 100644
--- a/TAO/tests/DynAny_Test/test_dynstruct.cpp
+++ b/TAO/tests/DynAny_Test/test_dynstruct.cpp
@@ -65,10 +65,13 @@ Test_DynStruct::run_test (void)
         DynamicAny::DynAnyFactory::_narrow (factory_obj.in (),
                                             ACE_TRY_ENV);
       ACE_TRY_CHECK;
+
       if (CORBA::is_nil (dynany_factory.in ()))
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           "Nil dynamic any factory after narrow\n"),
-                          -1);
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "Nil dynamic any factory after narrow\n"),
+                            -1);
+        }
 
       CORBA::Any in_any1;
       in_any1 <<= ts;
@@ -83,37 +86,54 @@ Test_DynStruct::run_test (void)
       fa1->insert_char (data.m_char1,
                         ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      fa1->next (ACE_TRY_ENV);
+      ACE_TRY_CHECK;
       fa1->insert_long (data.m_long1,
                         ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      fa1->next (ACE_TRY_ENV);
+      ACE_TRY_CHECK;
 
       DynamicAny::DynAny_var cc = fa1->current_component (ACE_TRY_ENV);
       ACE_TRY_CHECK;
       cc->insert_float (data.m_float1,
                         ACE_TRY_ENV);
       ACE_TRY_CHECK;
-
-      cc = fa1->current_component (ACE_TRY_ENV);
+      cc->next (ACE_TRY_ENV);
       ACE_TRY_CHECK;
       cc->insert_short (data.m_short1,
                         ACE_TRY_ENV);
       ACE_TRY_CHECK;
-
-      cc = fa1->current_component (ACE_TRY_ENV);
-      ACE_TRY_CHECK;
       cc->rewind (ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
+      // To show that calling destroy() on a component does
+      // nothing, as required by the spec.
+      cc->destroy (ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+
       fa1->rewind (ACE_TRY_ENV);
       ACE_TRY_CHECK;
       CORBA::Char c = fa1->get_char (ACE_TRY_ENV);
       ACE_TRY_CHECK;
+
       if (c != data.m_char1)
-        ++this->error_count_;
+        {
+          ++this->error_count_;
+        }
+
+      fa1->next (ACE_TRY_ENV);
+      ACE_TRY_CHECK;
       CORBA::Long l = fa1->get_long (ACE_TRY_ENV);
       ACE_TRY_CHECK;
+
       if (l != data.m_long1)
-        ++this->error_count_;
+        {
+          ++this->error_count_;
+        }
+
+      fa1->next (ACE_TRY_ENV);
+      ACE_TRY_CHECK;
 
       cc = fa1->current_component (ACE_TRY_ENV);
       ACE_TRY_CHECK;
@@ -121,16 +141,19 @@ Test_DynStruct::run_test (void)
                 ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
-      cc = fa1->current_component (ACE_TRY_ENV);
-      ACE_TRY_CHECK;
       CORBA::Short s = cc->get_short (ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
       if (s != data.m_short1)
-        ++this->error_count_;
+        {
+          ++this->error_count_;
+        }
+
       if (this->error_count_ == 0)
-        ACE_DEBUG ((LM_DEBUG,
-                   "++ OK ++\n"));
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                     "++ OK ++\n"));
+        }
 
       ACE_DEBUG ((LM_DEBUG,
                  "testing: constructor(TypeCode)/from_any/to_any\n"));
@@ -146,9 +169,11 @@ Test_DynStruct::run_test (void)
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (ftc1.in ()))
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           "DynStruct::_narrow() returned nil\n"),
-                          -1);
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "DynStruct::_narrow() returned nil\n"),
+                            -1);
+        }
 
       ts.c = data.m_char1;
       ts.l = data.m_long1;
@@ -163,11 +188,16 @@ Test_DynStruct::run_test (void)
       ACE_TRY_CHECK;
       DynAnyTests::test_struct* ts_out;
       out_any1.in () >>= ts_out;
+
       if (ts_out->es.s == data.m_short1)
-        ACE_DEBUG ((LM_DEBUG,
-                   "++ OK ++\n"));
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                     "++ OK ++\n"));
+        }
       else
-        ++this->error_count_;
+        {
+          ++this->error_count_;
+        }
 
       ACE_DEBUG ((LM_DEBUG,
                  "testing: current_member_name/current_member_kind\n"));
@@ -178,15 +208,25 @@ Test_DynStruct::run_test (void)
       DynamicAny::FieldName_var fn =
         ftc1->current_member_name (ACE_TRY_ENV);
       ACE_TRY_CHECK;
+
       if (ACE_OS::strcmp (fn.in (), "es"))
-        ++this->error_count_;
+        {
+          ++this->error_count_;
+        }
+
       CORBA::TCKind tk = ftc1->current_member_kind (ACE_TRY_ENV);
       ACE_TRY_CHECK;
+
       if (tk != CORBA::tk_struct)
-        ++this->error_count_;
+        {
+          ++this->error_count_;
+        }
+
       if (this->error_count_ == 0)
-        ACE_DEBUG ((LM_DEBUG,
-                   "++ OK ++\n"));
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                     "++ OK ++\n"));
+        }
 
       ACE_DEBUG ((LM_DEBUG,
                  "testing: get_members/set_members\n"));
diff --git a/TAO/tests/DynAny_Test/test_dynunion.cpp b/TAO/tests/DynAny_Test/test_dynunion.cpp
index 52c5f626244..f3b6d35a5d9 100644
--- a/TAO/tests/DynAny_Test/test_dynunion.cpp
+++ b/TAO/tests/DynAny_Test/test_dynunion.cpp
@@ -65,12 +65,15 @@ Test_DynUnion::run_test (void)
         DynamicAny::DynAnyFactory::_narrow (factory_obj.in (),
                                             ACE_TRY_ENV);
       ACE_TRY_CHECK;
+
       if (CORBA::is_nil (dynany_factory.in ()))
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           "Nil dynamic any factory after narrow\n"),
-                          -1);
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "Nil dynamic any factory after narrow\n"),
+                            -1);
+        }
 
-      tu._d(DynAnyTests::TE_SECOND);
+      tu._d (DynAnyTests::TE_SECOND);
       tu.tc (data.m_typecode2);
       CORBA_Any in_any1;
       in_any1 <<= tu;
@@ -82,16 +85,24 @@ Test_DynUnion::run_test (void)
         DynamicAny::DynUnion::_narrow (dp1.in (),
                                        ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      fa1->seek (1,
+                 ACE_TRY_ENV);
+      ACE_TRY_CHECK;
       fa1->insert_typecode (data.m_typecode1,
                             ACE_TRY_ENV);
       ACE_TRY_CHECK;
       CORBA::TypeCode_var s_out1 = fa1->get_typecode (ACE_TRY_ENV);
       ACE_TRY_CHECK;
+
       if (s_out1.in ()->equal (data.m_typecode1))
-        ACE_DEBUG ((LM_DEBUG,
-                   "++ OK ++\n"));
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                     "++ OK ++\n"));
+        }
       else
-        ++this->error_count_;
+        {
+          ++this->error_count_;
+        }
 
       ACE_DEBUG ((LM_DEBUG,
                  "testing: constructor(TypeCode)/from_any/to_any\n"));
@@ -109,13 +120,18 @@ Test_DynUnion::run_test (void)
       ACE_TRY_CHECK;
 
       if (CORBA::is_nil (ftc1.in ()))
-        ACE_ERROR_RETURN ((LM_ERROR,
-                           "DynUnion::_narrow() returned nil\n"),
-                          -1);
+        {
+          ACE_ERROR_RETURN ((LM_ERROR,
+                             "DynUnion::_narrow() returned nil\n"),
+                            -1);
+        }
 
       ftc1->from_any (out_any1.in (),
                       ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      ftc1->seek (1,
+                 ACE_TRY_ENV);
+      ACE_TRY_CHECK;
       CORBA::TypeCode_var s_out2 = ftc1->get_typecode (ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
@@ -129,16 +145,6 @@ Test_DynUnion::run_test (void)
           ++this->error_count_;
         }
 
-      // Not yet implemented.
-#if 0
-      ACE_DEBUG ((LM_DEBUG,
-                 "testing: set_to_default_member\n"));
-
-      ftc1->set_to_default_member (ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-      ACE_DEBUG ((LM_DEBUG,
-                  "++ OK ++\n"));
-#endif
       ACE_DEBUG ((LM_DEBUG,
                  "testing:discriminator/discriminator_kind\n"));
 
@@ -148,10 +154,12 @@ Test_DynUnion::run_test (void)
       CORBA::TypeCode_var tc2 = dp2->type (ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
-      CORBA::TCKind kind = ftc1->discriminator_kind (ACE_TRY_ENV);
+      CORBA::TCKind tc1kind = ftc1->discriminator_kind (ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      CORBA::TCKind tc2kind = tc2->kind (ACE_TRY_ENV);
       ACE_TRY_CHECK;
 
-      if (tc2->kind () == kind)
+      if (tc2kind == tc1kind)
         {
           ACE_DEBUG ((LM_DEBUG,
                      "++ OK ++\n"));
@@ -187,6 +195,31 @@ Test_DynUnion::run_test (void)
 
       ACE_TRY_CHECK;
 
+      ACE_DEBUG ((LM_DEBUG,
+                 "testing: set_to_default_member\n"));
+
+      ftc1->set_to_default_member (ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      ftc1->seek (1,
+                  ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      ftc1->insert_short (data.m_short1,
+                          ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      DynamicAny::DynAny_var mem = ftc1->member (ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      CORBA::Short out_s = mem->get_short (ACE_TRY_ENV);
+
+      if (out_s == data.m_short1)
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                      "++ OK ++\n"));
+        }
+      else
+        {
+          ++this->error_count_;
+        }
+
       fa1->destroy (ACE_TRY_ENV);
       ACE_TRY_CHECK;
       ftc1->destroy (ACE_TRY_ENV);