Index: no_ambiguity_in_boost.cpp
===================================================================
--- no_ambiguity_in_boost.cpp	(revision 48172)
+++ no_ambiguity_in_boost.cpp	(working copy)
@@ -25,11 +25,20 @@
 
 int test_main(int, char*[])
 {
-  boost::swap_test_class object1;
-  boost::swap_test_class object2;
+  const boost::swap_test_class initial_value1(1);
+  const boost::swap_test_class initial_value2(2);
+
+  boost::swap_test_class object1 = initial_value1;
+  boost::swap_test_class object2 = initial_value2;
+
+  boost::swap_test_class::reset();
+  
   boost::swap(object1,object2);
 
+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
   BOOST_CHECK_EQUAL(boost::swap_test_class::swap_count(),0);
+  BOOST_CHECK_EQUAL(boost::swap_test_class::swap_count(),0);
   BOOST_CHECK_EQUAL(boost::swap_test_class::copy_count(),3);
 
   return 0;
Index: specialized_in_boost.cpp
===================================================================
--- specialized_in_boost.cpp	(revision 48172)
+++ specialized_in_boost.cpp	(working copy)
@@ -25,10 +25,18 @@
 
 int test_main(int, char*[])
 {
-  boost::swap_test_class object1;
-  boost::swap_test_class object2;
+  const boost::swap_test_class initial_value1(1);
+  const boost::swap_test_class initial_value2(2);
+
+  boost::swap_test_class object1 = initial_value1;
+  boost::swap_test_class object2 = initial_value2;
+  
+  boost::swap_test_class::reset();
   boost::swap(object1,object2);
 
+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+
   BOOST_CHECK_EQUAL(boost::swap_test_class::swap_count(),1);
   BOOST_CHECK_EQUAL(boost::swap_test_class::copy_count(),0);
 
Index: specialized_in_boost_and_other.cpp
===================================================================
--- specialized_in_boost_and_other.cpp	(revision 48172)
+++ specialized_in_boost_and_other.cpp	(working copy)
@@ -44,10 +44,18 @@
 
 int test_main(int, char*[])
 {
-  other::swap_test_class object1;
-  other::swap_test_class object2;
+  const other::swap_test_class initial_value1(1);
+  const other::swap_test_class initial_value2(2);
+
+  other::swap_test_class object1 = initial_value1;
+  other::swap_test_class object2 = initial_value2;
+  
+  other::swap_test_class::reset();
   boost::swap(object1,object2);
 
+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+  
   BOOST_CHECK_EQUAL(other::swap_test_class::swap_count(),1);
   BOOST_CHECK_EQUAL(other::swap_test_class::copy_count(),0);
 
Index: specialized_in_global.cpp
===================================================================
--- specialized_in_global.cpp	(revision 48172)
+++ specialized_in_global.cpp	(working copy)
@@ -19,10 +19,18 @@
 
 int test_main(int, char*[])
 {
-  swap_test_class object1;
-  swap_test_class object2;
+  const swap_test_class initial_value1(1);
+  const swap_test_class initial_value2(2);
+
+  swap_test_class object1 = initial_value1;
+  swap_test_class object2 = initial_value2;
+  
+  swap_test_class::reset();
   boost::swap(object1,object2);
 
+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+  
   BOOST_CHECK_EQUAL(swap_test_class::swap_count(),1);
   BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);
 
Index: specialized_in_other.cpp
===================================================================
--- specialized_in_other.cpp	(revision 48172)
+++ specialized_in_other.cpp	(working copy)
@@ -25,10 +25,18 @@
 
 int test_main(int, char*[])
 {
-  other::swap_test_class object1;
-  other::swap_test_class object2;
+  const other::swap_test_class initial_value1(1);
+  const other::swap_test_class initial_value2(2);
+
+  other::swap_test_class object1 = initial_value1;
+  other::swap_test_class object2 = initial_value2;
+  
+  other::swap_test_class::reset();
   boost::swap(object1,object2);
 
+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+  
   BOOST_CHECK_EQUAL(other::swap_test_class::swap_count(),1);
   BOOST_CHECK_EQUAL(other::swap_test_class::copy_count(),0);
 
Index: std_vector_of_boost.cpp
===================================================================
--- std_vector_of_boost.cpp	(revision 48172)
+++ std_vector_of_boost.cpp	(working copy)
@@ -36,8 +36,11 @@
   const vector_type::size_type initial_size1 = 1;
   const vector_type::size_type initial_size2 = 2;
 
-  vector_type object1(initial_size1);
-  vector_type object2(initial_size2);
+  const vector_type initial_value1(initial_size1, swap_test_class_type(1));
+  const vector_type initial_value2(initial_size2, swap_test_class_type(2));
+  
+  vector_type object1 = initial_value1;
+  vector_type object2 = initial_value2;
 
   swap_test_class_type::reset();
   
@@ -46,6 +49,9 @@
   BOOST_CHECK_EQUAL(object1.size(),initial_size2);
   BOOST_CHECK_EQUAL(object2.size(),initial_size1);
 
+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+  
   BOOST_CHECK_EQUAL(swap_test_class_type::swap_count(),0);
   BOOST_CHECK_EQUAL(swap_test_class_type::copy_count(),0);
 
Index: std_vector_of_global.cpp
===================================================================
--- std_vector_of_global.cpp	(revision 48172)
+++ std_vector_of_global.cpp	(working copy)
@@ -29,8 +29,11 @@
   const vector_type::size_type initial_size1 = 1;
   const vector_type::size_type initial_size2 = 2;
 
-  vector_type object1(initial_size1);
-  vector_type object2(initial_size2);
+  const vector_type initial_value1(initial_size1, swap_test_class(1));
+  const vector_type initial_value2(initial_size2, swap_test_class(2));
+  
+  vector_type object1 = initial_value1;
+  vector_type object2 = initial_value2;
 
   swap_test_class::reset();
   
@@ -39,6 +42,9 @@
   BOOST_CHECK_EQUAL(object1.size(),initial_size2);
   BOOST_CHECK_EQUAL(object2.size(),initial_size1);
 
+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+
   BOOST_CHECK_EQUAL(swap_test_class::swap_count(),0);
   BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);
 
Index: std_vector_of_other.cpp
===================================================================
--- std_vector_of_other.cpp	(revision 48172)
+++ std_vector_of_other.cpp	(working copy)
@@ -36,8 +36,11 @@
   const vector_type::size_type initial_size1 = 1;
   const vector_type::size_type initial_size2 = 2;
 
-  vector_type object1(initial_size1);
-  vector_type object2(initial_size2);
+  const vector_type initial_value1(initial_size1, swap_test_class_type(1));
+  const vector_type initial_value2(initial_size2, swap_test_class_type(2));
+  
+  vector_type object1 = initial_value1;
+  vector_type object2 = initial_value2;
 
   swap_test_class_type::reset();
   
@@ -46,6 +49,9 @@
   BOOST_CHECK_EQUAL(object1.size(),initial_size2);
   BOOST_CHECK_EQUAL(object2.size(),initial_size1);
 
+  BOOST_CHECK(object1 == initial_value2);
+  BOOST_CHECK(object2 == initial_value1);
+
   BOOST_CHECK_EQUAL(swap_test_class_type::swap_count(),0);
   BOOST_CHECK_EQUAL(swap_test_class_type::copy_count(),0);
 
Index: swap_test_class.hpp
===================================================================
--- swap_test_class.hpp	(revision 48172)
+++ swap_test_class.hpp	(working copy)
@@ -12,8 +12,11 @@
 
 class swap_test_class
 {
+  int m_data;	
 public:
-  swap_test_class()
+  explicit swap_test_class(int arg = 0)
+  :
+  m_data(arg)
   {
     ++constructCount();
   }
@@ -23,23 +26,34 @@
     ++destructCount();
   }
 
-  swap_test_class(const swap_test_class&)
+  swap_test_class(const swap_test_class& arg)
+  :
+  m_data(arg.m_data)
   {
     ++copyCount();
     ++destructCount();
   }
 
-  swap_test_class& operator=(const swap_test_class&)
+  swap_test_class& operator=(const swap_test_class& arg)
   {
+    m_data = arg.m_data;
     ++copyCount();
     return *this;
   }
 
   void swap(swap_test_class& other)
   {
+    const int temp = m_data;
+    m_data = other.m_data;
+    other.m_data = temp;
+
     ++swapCount();
   }
 
+  int get_data() const
+  {
+    return m_data;
+  }
 
   static unsigned int swap_count(){ return swapCount(); }
   static unsigned int copy_count(){ return copyCount(); }
@@ -81,4 +95,15 @@
 
 };
 
+
+inline bool operator==(const swap_test_class & lhs, const swap_test_class & rhs)
+{
+  return lhs.get_data() == rhs.get_data();
+}
+
+inline bool operator!=(const swap_test_class & lhs, const swap_test_class & rhs)
+{
+  return !(lhs == rhs);
+}
+
 #endif