ChangeLogTag: Tue Nov 16 07:39:12 UTC 2005 Johnny Willemsen <jwillemsen@remedy.nl>

22 files changed, 601 insertions, 47 deletions

diff --git a/TAO/tests/Sequence_Unit_Tests/Sequence_Unit_Tests.mpc b/TAO/tests/Sequence_Unit_Tests/Sequence_Unit_Tests.mpc
index 2054b44732d..322fb600699 100644
--- a/TAO/tests/Sequence_Unit_Tests/Sequence_Unit_Tests.mpc
+++ b/TAO/tests/Sequence_Unit_Tests/Sequence_Unit_Tests.mpc
@@ -47,6 +47,32 @@ project(*Unbounded_Object_Reference_Sequence): taoexe, boost_unit_test_framework
   }
 }
 
+project(*Unbounded_Sequence_CDR): taoexe, boost_unit_test_framework {
+  exename = unbounded_sequence_cdr_ut
+  Source_Files {
+    mock_reference.cpp
+    mock_stream.cpp
+    unbounded_sequence_cdr_ut.cpp
+  }
+}
+
+project(*Bounded_Sequence_CDR): taoexe, boost_unit_test_framework {
+  exename = bounded_sequence_cdr_ut
+  Source_Files {
+    mock_reference.cpp
+    mock_stream.cpp
+    bounded_sequence_cdr_ut.cpp
+  }
+}
+
+project(*Unbounded_Fwd_Object_Reference_Sequence): taoexe, boost_unit_test_framework {
+  exename = unbounded_fwd_object_reference_sequence_ut
+  Source_Files {
+    fwd_mock_reference.cpp
+    unbounded_fwd_object_reference_sequence_ut.cpp
+  }
+}
+
 project(*Unbounded_Octet_Sequence): taoexe, boost_unit_test_framework {
   exename = unbounded_octet_sequence_ut
   Source_Files {
diff --git a/TAO/tests/Sequence_Unit_Tests/bounded_object_reference_sequence.hpp b/TAO/tests/Sequence_Unit_Tests/bounded_object_reference_sequence.hpp
index 4e5c4518fe8..e4140e3ef39 100644
--- a/TAO/tests/Sequence_Unit_Tests/bounded_object_reference_sequence.hpp
+++ b/TAO/tests/Sequence_Unit_Tests/bounded_object_reference_sequence.hpp
@@ -17,15 +17,16 @@
 namespace TAO
 {
 
-template<typename object_t, CORBA::ULong MAX>
+template<typename object_t, typename object_t_var, CORBA::ULong MAX>
 class bounded_object_reference_sequence
 {
 public:
   typedef object_t object_type;
   typedef object_type * value_type;
   typedef object_type const * const_value_type;
+  typedef object_t_var object_type_var;
 
-  typedef details::object_reference_traits<object_type,true> element_traits;
+  typedef details::object_reference_traits<object_type,object_type_var,true> element_traits;
   typedef details::bounded_reference_allocation_traits<value_type,element_traits,MAX,true> allocation_traits;
 
   typedef details::object_reference_sequence_element<element_traits> element_type;
diff --git a/TAO/tests/Sequence_Unit_Tests/bounded_object_reference_sequence_ut.cpp b/TAO/tests/Sequence_Unit_Tests/bounded_object_reference_sequence_ut.cpp
index 90d6be8b8ae..fa2b488f4d4 100644
--- a/TAO/tests/Sequence_Unit_Tests/bounded_object_reference_sequence_ut.cpp
+++ b/TAO/tests/Sequence_Unit_Tests/bounded_object_reference_sequence_ut.cpp
@@ -27,7 +27,7 @@ CORBA::ULong const TMAX = 64;
 
 struct Tester
 {
-  typedef bounded_object_reference_sequence<mock_reference,TMAX> tested_sequence;
+  typedef bounded_object_reference_sequence<mock_reference,mock_reference_var,TMAX> tested_sequence;
   typedef tested_sequence::value_type value_type;
   typedef tested_sequence::const_value_type const_value_type;
 
diff --git a/TAO/tests/Sequence_Unit_Tests/bounded_sequence_cdr.hpp b/TAO/tests/Sequence_Unit_Tests/bounded_sequence_cdr.hpp
new file mode 100644
index 00000000000..f6729bb45e1
--- /dev/null
+++ b/TAO/tests/Sequence_Unit_Tests/bounded_sequence_cdr.hpp
@@ -0,0 +1,56 @@
+#ifndef guard_bounded_sequence_cdr
+#define guard_bounded_sequence_cdr
+/**
+ * @file
+ *
+ * @brief Extract the sequence
+ *
+ * $Id$
+ *
+ * @author Carlos O'Ryan
+ * @author Johnny Willemsen
+ */
+
+namespace TAO {
+  namespace details {
+    template <typename stream, typename sequence>
+    bool extract_bounded_sequence(stream & strm, sequence & target) {
+      ::CORBA::ULong new_length;
+      if (!(strm >> new_length)) {
+        return false;
+      }
+      if (new_length > strm.length()) {
+         return false;
+      }
+      if (new_length > target.maximum ()) {
+         return false;
+      }
+      sequence tmp;
+      tmp.length(new_length);
+      typename sequence::value_type * buffer = tmp.get_buffer();
+      for(CORBA::ULong i = 0; i < new_length; ++i) {
+        if (!(strm >> buffer[i])) {
+          return false;
+        }
+      }
+      tmp.swap(target);
+      return true;
+    }
+
+    template <typename stream, typename sequence>
+    bool insert_bounded_sequence(stream & strm, const sequence & source) {
+      const ::CORBA::ULong length = source.length ();
+      if (!(strm << length)) {
+        return false;
+      }
+      for(CORBA::ULong i = 0; i < length; ++i) {
+        if (!(strm << source[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+}
+
+#endif /* guard_bounded_sequence_cdr */
diff --git a/TAO/tests/Sequence_Unit_Tests/bounded_sequence_cdr_ut.cpp b/TAO/tests/Sequence_Unit_Tests/bounded_sequence_cdr_ut.cpp
new file mode 100644
index 00000000000..3bb7b983e83
--- /dev/null
+++ b/TAO/tests/Sequence_Unit_Tests/bounded_sequence_cdr_ut.cpp
@@ -0,0 +1,125 @@
+/**
+ * @file
+ *
+ * @brief Unit test for bounded sequences of object references.
+ *
+ * $Id$
+ *
+ * @author Carlos O'Ryan
+ */
+#include "testing_object_reference_traits.hpp"
+#include "object_reference_traits.hpp"
+#include "testing_allocation_traits.hpp"
+#include "testing_range_checking.hpp"
+
+#include "mock_reference.hpp"
+#include "mock_stream.hpp"
+
+#include "bounded_object_reference_sequence.hpp"
+#include "bounded_sequence_cdr.hpp"
+
+#include <boost/test/unit_test.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+
+using namespace boost::unit_test_framework;
+using namespace TAO;
+
+CORBA::ULong const TMAX = 64;
+
+typedef bounded_object_reference_sequence<mock_reference, mock_reference_var,TMAX> tested_sequence;
+
+CORBA::Boolean operator<< (mock_stream &strm, const tested_sequence &sequence)
+{
+  return TAO::details::insert_bounded_sequence(strm, sequence);
+}
+
+CORBA::Boolean operator>> (mock_stream &strm, tested_sequence &sequence)
+{
+  return TAO::details::extract_bounded_sequence(strm, sequence);
+}
+
+struct Tester
+{
+  typedef tested_sequence::value_type value_type;
+  typedef tested_sequence::const_value_type const_value_type;
+
+  typedef tested_sequence::element_traits tested_element_traits;
+  typedef tested_sequence::allocation_traits tested_allocation_traits;
+  typedef TAO::details::range_checking<value_type,true> range;
+
+  value_type * alloc_and_init_buffer()
+  {
+    value_type * buf = tested_sequence::allocbuf(8);
+    buf[0] = mock_reference::allocate(1);
+    buf[1] = mock_reference::allocate(4);
+    buf[2] = mock_reference::allocate(9);
+    buf[3] = mock_reference::allocate(16);
+
+    return buf;
+  }
+
+  void check_values(tested_sequence const & a)
+  {
+    BOOST_CHECK_EQUAL( 1, a[0]->id());
+    BOOST_CHECK_EQUAL( 4, a[1]->id());
+    BOOST_CHECK_EQUAL( 9, a[2]->id());
+    BOOST_CHECK_EQUAL(16, a[3]->id());
+  }
+
+  void test_stream()
+  {
+    value_type * buffer = alloc_and_init_buffer();
+
+    expected_calls s(mock_reference::serialize_calls);
+    {
+      tested_sequence a;
+      a.replace(4, buffer, false);
+
+      BOOST_CHECK_EQUAL(CORBA::ULong(64), a.maximum());
+      BOOST_CHECK_EQUAL(CORBA::ULong(4), a.length());
+      BOOST_CHECK_EQUAL(buffer, a.get_buffer());
+      BOOST_CHECK_EQUAL(false, a.release());
+      check_values(a);
+
+      mock_stream stream;
+      stream << a;
+      BOOST_CHECK_MESSAGE(s.expect(4), s);
+    }
+    tested_sequence::freebuf(buffer);
+  }
+
+  void add_all(test_suite * ts)
+  {
+    boost::shared_ptr<Tester> shared_this(self_);
+    ts->add(BOOST_CLASS_TEST_CASE(
+                &Tester::test_stream,
+                shared_this));
+  }
+
+  static boost::shared_ptr<Tester> allocate()
+  {
+    boost::shared_ptr<Tester> ptr(new Tester);
+    ptr->self_ = ptr;
+
+    return ptr;
+  }
+
+private:
+  Tester() {}
+
+  boost::weak_ptr<Tester> self_;
+};
+
+test_suite *
+init_unit_test_suite(int, char*[])
+{
+  test_suite * ts =
+      BOOST_TEST_SUITE("unbounded object reference sequence unit test");
+
+  boost::shared_ptr<Tester> tester(Tester::allocate());
+  tester->add_all(ts);
+
+  return ts;
+}
+
diff --git a/TAO/tests/Sequence_Unit_Tests/bounded_value_sequence.hpp b/TAO/tests/Sequence_Unit_Tests/bounded_value_sequence.hpp
index bbbb54f3f8d..0f1fb4b609a 100644
--- a/TAO/tests/Sequence_Unit_Tests/bounded_value_sequence.hpp
+++ b/TAO/tests/Sequence_Unit_Tests/bounded_value_sequence.hpp
@@ -23,6 +23,7 @@ class bounded_value_sequence
 {
 public:
   typedef T value_type;
+  typedef T element_type;
   typedef T const const_value_type;
 
   typedef details::bounded_value_allocation_traits<value_type,MAX,true> allocation_traits;
diff --git a/TAO/tests/Sequence_Unit_Tests/mock_reference.cpp b/TAO/tests/Sequence_Unit_Tests/mock_reference.cpp
index 4c72a54f449..a4ef6d8e6b0 100644
--- a/TAO/tests/Sequence_Unit_Tests/mock_reference.cpp
+++ b/TAO/tests/Sequence_Unit_Tests/mock_reference.cpp
@@ -9,6 +9,8 @@
 
 call_counter mock_reference::duplicate_calls;
 call_counter mock_reference::release_calls;
+call_counter mock_reference::serialize_calls;
+call_counter mock_reference::deserialize_calls;
 
 mock_reference::
 ~mock_reference()
@@ -49,3 +51,45 @@ void CORBA::release(mock_reference * r)
 {
   mock_reference::_tao_release(r);
 }
+
+mock_reference *
+TAO::Objref_Traits<mock_reference>::duplicate (
+    mock_reference_ptr p
+  )
+{
+  return mock_reference::_duplicate (p);
+}
+
+void
+TAO::Objref_Traits<mock_reference>::release (
+    mock_reference_ptr p
+  )
+{
+  CORBA::release (p);
+}
+
+mock_reference_ptr
+TAO::Objref_Traits<mock_reference>::nil (void)
+{
+  return mock_reference::_nil ();
+}
+
+CORBA::Boolean
+TAO::Objref_Traits<mock_reference>::marshal (
+    mock_reference_ptr,
+    TAO_OutputCDR &
+  )
+{
+  return true;
+}
+
+CORBA::Boolean operator<< (mock_stream &, const mock_reference *)
+{
+  mock_reference::serialize_calls ();
+  return true;
+}
+CORBA::Boolean operator>> (mock_stream &, mock_reference *&)
+{
+  mock_reference::deserialize_calls ();
+  return true;
+}
diff --git a/TAO/tests/Sequence_Unit_Tests/mock_reference.hpp b/TAO/tests/Sequence_Unit_Tests/mock_reference.hpp
index 9fa945e3e3a..5a219188c86 100644
--- a/TAO/tests/Sequence_Unit_Tests/mock_reference.hpp
+++ b/TAO/tests/Sequence_Unit_Tests/mock_reference.hpp
@@ -24,8 +24,13 @@ namespace CORBA
 void release(mock_reference*);
 }
 
-#include "tao/Pseudo_VarOut_T.h"
+class mock_stream;
 
+#include "tao/Objref_VarOut_T.h"
+
+typedef mock_reference *mock_reference_ptr;
+typedef TAO_Objref_Var_T<mock_reference> mock_reference_var;
+typedef TAO_Objref_Out_T<mock_reference> mock_reference_out;
 
 /**
  * @class mock_reference
@@ -38,8 +43,8 @@ class mock_reference
 public:
   virtual ~mock_reference();
 
-  typedef TAO_Pseudo_Var_T<mock_reference> _var_type;
-  typedef TAO_Pseudo_Out_T<mock_reference,_var_type> _out_type;
+  typedef mock_reference_var _var_type;
+  typedef mock_reference_out _out_type;
 
   static mock_reference * allocate(int id);
   static mock_reference * _nil();
@@ -48,6 +53,8 @@ public:
   static mock_reference * _duplicate(mock_reference * rhs);
   static call_counter release_calls;
   static void _tao_release(mock_reference * rhs);
+  static call_counter serialize_calls;
+  static call_counter deserialize_calls;
 
   inline bool operator==(mock_reference const & rhs) const
   {
@@ -65,6 +72,8 @@ public:
   }
 
 private:
+  mock_reference ();
+
   inline mock_reference(int id)
     : id_(id)
   {}
@@ -73,8 +82,19 @@ private:
   int id_;
 };
 
-typedef mock_reference * mock_reference_ptr;
-typedef mock_reference::_var_type mock_reference_var;
-typedef mock_reference::_out_type mock_reference_out;
+CORBA::Boolean operator<< (mock_stream &, const mock_reference *);
+CORBA::Boolean operator>> (mock_stream &, mock_reference *&);
+
+namespace TAO
+{
+  template<>
+  struct Objref_Traits< mock_reference>
+  {
+    static mock_reference_ptr duplicate (mock_reference_ptr);
+    static void release (mock_reference_ptr);
+    static mock_reference_ptr nil (void);
+    static CORBA::Boolean marshal (mock_reference_ptr p, TAO_OutputCDR & cdr);
+  };
+}
 
 #endif // guard_mock_reference_hpp
diff --git a/TAO/tests/Sequence_Unit_Tests/mock_stream.cpp b/TAO/tests/Sequence_Unit_Tests/mock_stream.cpp
index e8cdeca52cc..f84d6d22435 100644
--- a/TAO/tests/Sequence_Unit_Tests/mock_stream.cpp
+++ b/TAO/tests/Sequence_Unit_Tests/mock_stream.cpp
@@ -15,6 +15,12 @@ mock_stream::
 {
 }
 
+CORBA::ULong
+mock_stream::length () const
+{
+  return 100;
+}
+
 CORBA::Boolean operator<< (mock_stream &, const CORBA::ULong)
 {
   return true;
diff --git a/TAO/tests/Sequence_Unit_Tests/mock_stream.hpp b/TAO/tests/Sequence_Unit_Tests/mock_stream.hpp
index fc1c9ff691d..5dab6c013c9 100644
--- a/TAO/tests/Sequence_Unit_Tests/mock_stream.hpp
+++ b/TAO/tests/Sequence_Unit_Tests/mock_stream.hpp
@@ -17,13 +17,14 @@
 /**
  * @class mock_stream
  *
- * @brief Implement a concrete class with the right interface for an
- *        object reference.
+ * @brief Implement a concrete class with the right interface for a stream.
  */
 class mock_stream
 {
 public:
-  virtual ~mock_stream();
+  ~mock_stream();
+
+  CORBA::ULong length () const;
 
   static call_counter serialize_calls;
   static call_counter deserialize_calls;
diff --git a/TAO/tests/Sequence_Unit_Tests/object_reference_sequence_element_ut.cpp b/TAO/tests/Sequence_Unit_Tests/object_reference_sequence_element_ut.cpp
index 7e994140770..0b57f6d5c6e 100644
--- a/TAO/tests/Sequence_Unit_Tests/object_reference_sequence_element_ut.cpp
+++ b/TAO/tests/Sequence_Unit_Tests/object_reference_sequence_element_ut.cpp
@@ -26,7 +26,7 @@ using namespace boost::unit_test_framework;
 
 struct Tester
 {
-  typedef object_reference_traits<mock_reference,true> tested_element_traits;
+  typedef object_reference_traits<mock_reference,mock_reference_var,true> tested_element_traits;
   typedef object_reference_sequence_element<tested_element_traits> tested_element;
   typedef mock_reference * reference_type;
   typedef tested_element_traits::object_type_var reference_var;
diff --git a/TAO/tests/Sequence_Unit_Tests/object_reference_traits.hpp b/TAO/tests/Sequence_Unit_Tests/object_reference_traits.hpp
index 0075f4a1ff3..2d5326793c9 100644
--- a/TAO/tests/Sequence_Unit_Tests/object_reference_traits.hpp
+++ b/TAO/tests/Sequence_Unit_Tests/object_reference_traits.hpp
@@ -4,7 +4,7 @@
  * @file
  *
  * @brief Implement the element manipulation traits for object
- *        reference types. 
+ *        reference types.
  *
  * $Id$
  *
@@ -20,14 +20,13 @@ namespace TAO
 namespace details
 {
 
-template<class object_t, class derived>
+template<class object_t, class object_t_var, class derived>
 struct object_reference_traits_decorator
 {
   typedef object_t object_type;
   typedef object_type * value_type;
   typedef object_type const * const_value_type;
-
-  typedef typename object_type::_var_type object_type_var;
+  typedef object_t_var object_type_var;
 
   inline static void zero_range(
       object_type ** begin, object_type ** end)
@@ -63,11 +62,17 @@ struct object_reference_traits_decorator
   }
 };
 
-template<typename object_t, bool dummy>
+template<typename object_t, typename object_t_var, bool dummy>
 struct object_reference_traits
-  : public object_reference_traits_base<object_t>
-  , public object_reference_traits_decorator<object_t, object_reference_traits<object_t,dummy> >
+  : public object_reference_traits_base<object_t, object_t_var>
+  , public object_reference_traits_decorator<object_t, object_t_var, object_reference_traits<object_t,object_t_var,dummy> >
 {
+#if defined __BORLANDC__ && __BORLANDC__ < 0x580
+  typedef object_t object_type;
+  typedef object_type * value_type;
+  typedef object_type const * const_value_type;
+  typedef object_t_var object_type_var;
+#endif
 };
 
 } // namespace details
diff --git a/TAO/tests/Sequence_Unit_Tests/object_reference_traits_base.hpp b/TAO/tests/Sequence_Unit_Tests/object_reference_traits_base.hpp
index a05b224f327..9a1b30cf00b 100644
--- a/TAO/tests/Sequence_Unit_Tests/object_reference_traits_base.hpp
+++ b/TAO/tests/Sequence_Unit_Tests/object_reference_traits_base.hpp
@@ -1,5 +1,5 @@
-#ifndef guard_string_traits_base_hpp
-#define guard_string_traits_base_hpp
+#ifndef object_reference_traits_base_hpp
+#define object_reference_traits_base_hpp
 /**
  * @file
  *
@@ -10,33 +10,34 @@
  * @author Carlos O'Ryan
  */
 
+#include "tao/Objref_VarOut_T.h"
+
 namespace TAO
 {
 namespace details
 {
 
-template<typename object_t>
+template<typename object_t, typename object_t_var>
 struct object_reference_traits_base
 {
   typedef object_t object_type;
   typedef object_type * value_type;
   typedef object_type const * const_value_type;
-
-  typedef typename object_type::_var_type object_type_var;
+  typedef object_t_var object_type_var;
 
   inline static void release(object_type * object)
   {
-    object_type::_tao_release(object);
+    TAO::Objref_Traits<object_type>::release(object);
   }
 
   inline static object_type * duplicate(object_type * object)
   {
-    return object_type::_duplicate(object);
+    return TAO::Objref_Traits<object_type>::duplicate(object);
   }
 
   inline static object_type * nil()
   {
-    return object_type::_nil();
+    return TAO::Objref_Traits<object_type>::nil();
   }
 
   inline static object_type * default_initializer()
@@ -48,4 +49,4 @@ struct object_reference_traits_base
 } // namespace details
 } // namespace TAO
 
-#endif // guard_string_traits_base_hpp
+#endif // object_reference_traits_base_hpp
diff --git a/TAO/tests/Sequence_Unit_Tests/run_test.pl b/TAO/tests/Sequence_Unit_Tests/run_test.pl
index afe54111ed3..9d1e5babf6e 100755
--- a/TAO/tests/Sequence_Unit_Tests/run_test.pl
+++ b/TAO/tests/Sequence_Unit_Tests/run_test.pl
@@ -21,7 +21,10 @@ my @tests = qw(unbounded_value_sequence_ut
                unbounded_octet_sequence_no_copy_ut
                object_reference_sequence_element_ut
                unbounded_object_reference_sequence_ut
+               unbounded_fwd_object_reference_sequence_ut
                bounded_object_reference_sequence_ut
+               bounded_sequence_cdr_ut
+               unbounded_sequence_cdr_ut
                Unbounded_Octet
                Unbounded_Simple_Types
                Bounded_Simple_Types
diff --git a/TAO/tests/Sequence_Unit_Tests/testing_object_reference_traits.hpp b/TAO/tests/Sequence_Unit_Tests/testing_object_reference_traits.hpp
index 6abe33f9dc0..5aedefcf249 100644
--- a/TAO/tests/Sequence_Unit_Tests/testing_object_reference_traits.hpp
+++ b/TAO/tests/Sequence_Unit_Tests/testing_object_reference_traits.hpp
@@ -4,7 +4,7 @@
  * @file
  *
  * @brief Specialize the object reference traits so they can be used
- *        in testing. 
+ *        in testing.
  *
  * $Id$
  *
@@ -15,18 +15,18 @@
 #include "testing_counters.hpp"
 #include "object_reference_traits.hpp"
 
-template<typename object_t>
+template<typename object_t, typename object_t_var>
 struct testing_object_reference_traits
-  : public TAO::details::object_reference_traits_base<object_t>
-  , public TAO::details::object_reference_traits_decorator<object_t, testing_object_reference_traits<object_t> >
+  : public TAO::details::object_reference_traits_base<object_t, object_t_var>
+  , public TAO::details::object_reference_traits_decorator<object_t, object_t_var, testing_object_reference_traits<object_t, object_t_var> >
 {
   static call_counter default_initializer_calls;
   static call_counter duplicate_calls;
   static call_counter release_calls;
 
   typedef object_t object_type;
-  typedef typename object_type::_var_type object_type_var;
-  typedef TAO::details::object_reference_traits<object_t,false> real_traits;
+  typedef object_t_var object_type_var;
+  typedef TAO::details::object_reference_traits<object_t,object_t_var,false> real_traits;
 
   static object_type * default_initializer()
   {
@@ -47,23 +47,23 @@ struct testing_object_reference_traits
   }
 };
 
-template<typename object_t> call_counter
-testing_object_reference_traits<object_t>::default_initializer_calls;
+template<typename object_t,typename object_t_var> call_counter
+testing_object_reference_traits<object_t,object_t_var>::default_initializer_calls;
 
-template<typename object_t> call_counter
-testing_object_reference_traits<object_t>::duplicate_calls;
+template<typename object_t,typename object_t_var> call_counter
+testing_object_reference_traits<object_t,object_t_var>::duplicate_calls;
 
-template<typename object_t> call_counter
-testing_object_reference_traits<object_t>::release_calls;
+template<typename object_t,typename object_t_var> call_counter
+testing_object_reference_traits<object_t,object_t_var>::release_calls;
 
 namespace TAO
 {
 namespace details
 {
 
-template<typename object_t>
-struct object_reference_traits<object_t,true>
-  : public testing_object_reference_traits<object_t>
+template<typename object_t, typename object_t_var>
+struct object_reference_traits<object_t,object_t_var,true>
+  : public testing_object_reference_traits<object_t,object_t_var>
 {
 };
 
diff --git a/TAO/tests/Sequence_Unit_Tests/unbounded_fwd_object_reference_sequence_ut.cpp b/TAO/tests/Sequence_Unit_Tests/unbounded_fwd_object_reference_sequence_ut.cpp
new file mode 100644
index 00000000000..d44308269d9
--- /dev/null
+++ b/TAO/tests/Sequence_Unit_Tests/unbounded_fwd_object_reference_sequence_ut.cpp
@@ -0,0 +1,87 @@
+/**
+ * @file
+ *
+ * @brief Unit test for unbounded sequences of forward declared object
+ * references.
+ *
+ * $Id$
+ *
+ * @author Johnny Willemsen  <jwillemsen@remedy.nl>
+ */
+#include "testing_object_reference_traits.hpp"
+//#include "object_reference_traits.hpp"
+#include "testing_allocation_traits.hpp"
+#include "testing_range_checking.hpp"
+
+#include "fwd_mock_reference.hpp"
+
+#include "unbounded_object_reference_sequence.hpp"
+
+#include <boost/test/unit_test.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+
+using namespace boost::unit_test_framework;
+using namespace TAO;
+
+struct Tester
+{
+  typedef unbounded_object_reference_sequence<fwd_mock_reference, fwd_mock_reference_var> tested_sequence;
+  typedef tested_sequence::value_type value_type;
+  typedef tested_sequence::const_value_type const_value_type;
+
+  typedef tested_sequence::element_traits tested_element_traits;
+  typedef tested_sequence::allocation_traits tested_allocation_traits;
+  typedef TAO::details::range_checking<value_type,true> range;
+
+  void test_default_constructor()
+  {
+    expected_calls a(tested_allocation_traits::allocbuf_calls);
+    expected_calls f(tested_allocation_traits::freebuf_calls);
+    expected_calls i(tested_element_traits::default_initializer_calls);
+    {
+      tested_sequence x;
+
+      BOOST_CHECK_EQUAL(CORBA::ULong(0), x.maximum());
+      BOOST_CHECK_EQUAL(CORBA::ULong(0), x.length());
+      BOOST_CHECK_EQUAL(true, x.release());
+    }
+    BOOST_CHECK_MESSAGE(a.expect(0), a);
+    BOOST_CHECK_MESSAGE(f.expect(1), f);
+    BOOST_CHECK_MESSAGE(i.expect(0), i);
+  }
+
+  void add_all(test_suite * ts)
+  {
+    boost::shared_ptr<Tester> shared_this(self_);
+    ts->add(BOOST_CLASS_TEST_CASE(
+                &Tester::test_default_constructor,
+                shared_this));
+  }
+
+  static boost::shared_ptr<Tester> allocate()
+  {
+    boost::shared_ptr<Tester> ptr(new Tester);
+    ptr->self_ = ptr;
+
+    return ptr;
+  }
+
+private:
+  Tester() {}
+
+  boost::weak_ptr<Tester> self_;
+};
+
+test_suite *
+init_unit_test_suite(int, char*[])
+{
+  test_suite * ts =
+      BOOST_TEST_SUITE("unbounded object reference sequence unit test");
+
+  boost::shared_ptr<Tester> tester(Tester::allocate());
+  tester->add_all(ts);
+
+  return ts;
+}
+
diff --git a/TAO/tests/Sequence_Unit_Tests/unbounded_object_reference_sequence.hpp b/TAO/tests/Sequence_Unit_Tests/unbounded_object_reference_sequence.hpp
index 23ebd2c28b1..ec459ea7d8a 100644
--- a/TAO/tests/Sequence_Unit_Tests/unbounded_object_reference_sequence.hpp
+++ b/TAO/tests/Sequence_Unit_Tests/unbounded_object_reference_sequence.hpp
@@ -17,7 +17,7 @@
 namespace TAO
 {
 
-template<typename object_t>
+template<typename object_t, typename object_t_var>
 class unbounded_object_reference_sequence
 {
 public:
@@ -25,7 +25,7 @@ public:
   typedef object_type * value_type;
   typedef object_type const * const_value_type;
 
-  typedef details::object_reference_traits<object_type,true> element_traits;
+  typedef details::object_reference_traits<object_type,object_t_var,true> element_traits;
   typedef details::unbounded_reference_allocation_traits<value_type,element_traits,true> allocation_traits;
 
   typedef details::object_reference_sequence_element<element_traits> element_type;
diff --git a/TAO/tests/Sequence_Unit_Tests/unbounded_object_reference_sequence_ut.cpp b/TAO/tests/Sequence_Unit_Tests/unbounded_object_reference_sequence_ut.cpp
index 1e1e598c25a..af4fff33cf1 100644
--- a/TAO/tests/Sequence_Unit_Tests/unbounded_object_reference_sequence_ut.cpp
+++ b/TAO/tests/Sequence_Unit_Tests/unbounded_object_reference_sequence_ut.cpp
@@ -25,7 +25,7 @@ using namespace TAO;
 
 struct Tester
 {
-  typedef unbounded_object_reference_sequence<mock_reference> tested_sequence;
+  typedef unbounded_object_reference_sequence<mock_reference, mock_reference_var> tested_sequence;
   typedef tested_sequence::value_type value_type;
   typedef tested_sequence::const_value_type const_value_type;
 
diff --git a/TAO/tests/Sequence_Unit_Tests/unbounded_octet_sequence.hpp b/TAO/tests/Sequence_Unit_Tests/unbounded_octet_sequence.hpp
index d752fe7ef6c..5b261ca3052 100644
--- a/TAO/tests/Sequence_Unit_Tests/unbounded_octet_sequence.hpp
+++ b/TAO/tests/Sequence_Unit_Tests/unbounded_octet_sequence.hpp
@@ -30,6 +30,7 @@ class unbounded_value_sequence<CORBA::Octet>
 {
 public:
   typedef CORBA::Octet value_type;
+  typedef CORBA::Octet element_type;
   typedef CORBA::Octet const const_value_type;
 
   typedef details::unbounded_value_allocation_traits<value_type,true> allocation_traits;
diff --git a/TAO/tests/Sequence_Unit_Tests/unbounded_sequence_cdr.hpp b/TAO/tests/Sequence_Unit_Tests/unbounded_sequence_cdr.hpp
new file mode 100644
index 00000000000..a17997c7fc7
--- /dev/null
+++ b/TAO/tests/Sequence_Unit_Tests/unbounded_sequence_cdr.hpp
@@ -0,0 +1,53 @@
+#ifndef guard_unbounded_sequence_cdr
+#define guard_unbounded_sequence_cdr
+/**
+ * @file
+ *
+ * @brief Extract the sequence
+ *
+ * $Id$
+ *
+ * @author Carlos O'Ryan
+ * @author Johnny Willemsen
+ */
+
+namespace TAO {
+  namespace details {
+    template <typename stream, typename sequence>
+    bool extract_unbounded_sequence(stream & strm, sequence & target) {
+      ::CORBA::ULong new_length;
+      if (!(strm >> new_length)) {
+        return false;
+      }
+      if (new_length > strm.length()) {
+         return false;
+      }
+      sequence tmp(new_length);
+      tmp.length(new_length);
+      typename sequence::value_type * buffer = tmp.get_buffer();
+      for(CORBA::ULong i = 0; i < new_length; ++i) {
+        if (!(strm >> buffer[i])) {
+          return false;
+        }
+      }
+      tmp.swap(target);
+      return true;
+    }
+
+    template <typename stream, typename sequence>
+    bool insert_unbounded_sequence(stream & strm, const sequence & source) {
+      const ::CORBA::ULong length = source.length ();
+      if (!(strm << length)) {
+        return false;
+      }
+      for(CORBA::ULong i = 0; i < length; ++i) {
+        if (!(strm << source[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+}
+
+#endif /* guard_unbounded_sequence_cdr */
diff --git a/TAO/tests/Sequence_Unit_Tests/unbounded_sequence_cdr_ut.cpp b/TAO/tests/Sequence_Unit_Tests/unbounded_sequence_cdr_ut.cpp
new file mode 100644
index 00000000000..9331db1ba1d
--- /dev/null
+++ b/TAO/tests/Sequence_Unit_Tests/unbounded_sequence_cdr_ut.cpp
@@ -0,0 +1,123 @@
+/**
+ * @file
+ *
+ * @brief Unit test for unbounded sequences of object references.
+ *
+ * $Id$
+ *
+ * @author Carlos O'Ryan
+ */
+#include "testing_object_reference_traits.hpp"
+#include "object_reference_traits.hpp"
+#include "testing_allocation_traits.hpp"
+#include "testing_range_checking.hpp"
+
+#include "mock_reference.hpp"
+#include "mock_stream.hpp"
+
+#include "unbounded_object_reference_sequence.hpp"
+#include "unbounded_sequence_cdr.hpp"
+
+#include <boost/test/unit_test.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+
+using namespace boost::unit_test_framework;
+using namespace TAO;
+
+typedef unbounded_object_reference_sequence<mock_reference, mock_reference_var> tested_sequence;
+
+CORBA::Boolean operator<< (mock_stream &strm, const tested_sequence &sequence)
+{
+  return TAO::details::insert_unbounded_sequence(strm, sequence);
+}
+
+CORBA::Boolean operator>> (mock_stream &strm, tested_sequence &sequence)
+{
+  return TAO::details::extract_unbounded_sequence(strm, sequence);
+}
+
+struct Tester
+{
+  typedef tested_sequence::value_type value_type;
+  typedef tested_sequence::const_value_type const_value_type;
+
+  typedef tested_sequence::element_traits tested_element_traits;
+  typedef tested_sequence::allocation_traits tested_allocation_traits;
+  typedef TAO::details::range_checking<value_type,true> range;
+
+  value_type * alloc_and_init_buffer()
+  {
+    value_type * buf = tested_sequence::allocbuf(8);
+    buf[0] = mock_reference::allocate(1);
+    buf[1] = mock_reference::allocate(4);
+    buf[2] = mock_reference::allocate(9);
+    buf[3] = mock_reference::allocate(16);
+
+    return buf;
+  }
+
+  void check_values(tested_sequence const & a)
+  {
+    BOOST_CHECK_EQUAL( 1, a[0]->id());
+    BOOST_CHECK_EQUAL( 4, a[1]->id());
+    BOOST_CHECK_EQUAL( 9, a[2]->id());
+    BOOST_CHECK_EQUAL(16, a[3]->id());
+  }
+
+  void test_stream()
+  {
+    value_type * buffer = alloc_and_init_buffer();
+
+    expected_calls s(mock_reference::serialize_calls);
+    {
+      tested_sequence a;
+      a.replace(8, 4, buffer, false);
+
+      BOOST_CHECK_EQUAL(CORBA::ULong(8), a.maximum());
+      BOOST_CHECK_EQUAL(CORBA::ULong(4), a.length());
+      BOOST_CHECK_EQUAL(buffer, a.get_buffer());
+      BOOST_CHECK_EQUAL(false, a.release());
+      check_values(a);
+
+      mock_stream stream;
+      stream << a;
+      BOOST_CHECK_MESSAGE(s.expect(4), s);
+    }
+    tested_sequence::freebuf(buffer);
+  }
+
+  void add_all(test_suite * ts)
+  {
+    boost::shared_ptr<Tester> shared_this(self_);
+    ts->add(BOOST_CLASS_TEST_CASE(
+                &Tester::test_stream,
+                shared_this));
+  }
+
+  static boost::shared_ptr<Tester> allocate()
+  {
+    boost::shared_ptr<Tester> ptr(new Tester);
+    ptr->self_ = ptr;
+
+    return ptr;
+  }
+
+private:
+  Tester() {}
+
+  boost::weak_ptr<Tester> self_;
+};
+
+test_suite *
+init_unit_test_suite(int, char*[])
+{
+  test_suite * ts =
+      BOOST_TEST_SUITE("unbounded object reference sequence unit test");
+
+  boost::shared_ptr<Tester> tester(Tester::allocate());
+  tester->add_all(ts);
+
+  return ts;
+}
+
diff --git a/TAO/tests/Sequence_Unit_Tests/unbounded_value_sequence.hpp b/TAO/tests/Sequence_Unit_Tests/unbounded_value_sequence.hpp
index c52b542abd8..0480ee957d4 100644
--- a/TAO/tests/Sequence_Unit_Tests/unbounded_value_sequence.hpp
+++ b/TAO/tests/Sequence_Unit_Tests/unbounded_value_sequence.hpp
@@ -23,6 +23,7 @@ class unbounded_value_sequence
 {
 public:
   typedef T value_type;
+  typedef T element_type;
   typedef T const const_value_type;
 
   typedef details::unbounded_value_allocation_traits<value_type,true> allocation_traits;