[Boost-commit] svn:boost r48247 - trunk/libs/utility/swap/test

From: nielsdekker_at_[hidden]
Date: 2008-08-20 04:29:55

Author: niels_dekker
Date: 2008-08-20 04:29:54 EDT (Wed, 20 Aug 2008)
New Revision: 48247
URL: http://svn.boost.org/trac/boost/changeset/48247

Log:
Extended swap_arrays test, checking that boost::swap does correctly exchange the values of its arguments.
Text files modified: 
   trunk/libs/utility/swap/test/swap_arrays.cpp |    63 +++++++++++++++++++++++++++++++++------ 
   1 files changed, 52 insertions(+), 11 deletions(-)

Modified: trunk/libs/utility/swap/test/swap_arrays.cpp
==============================================================================
--- trunk/libs/utility/swap/test/swap_arrays.cpp	(original)
+++ trunk/libs/utility/swap/test/swap_arrays.cpp	2008-08-20 04:29:54 EDT (Wed, 20 Aug 2008)
@@ -11,6 +11,9 @@
 //Put test class in the global namespace
 #include "./swap_test_class.hpp"
 
+#include <algorithm> //for std::copy and std::equal
+#include <cstddef> //for std::size_t
+
 //Provide swap function in both the namespace of swap_test_class
 //(which is the global namespace), and the std namespace.
 //It's common to provide a swap function for a class in both
@@ -30,29 +33,67 @@
   }
 }
 
-
-int test_main(int, char*[])
+// Tests swapping 1-dimensional arrays.
+void test_swapping_1D_arrays()
 {
-  const std::size_t dimension = 7;
-
+  const std::size_t dimension = 2;
+  const swap_test_class initial_array1[dimension] = { swap_test_class(1), swap_test_class(2) };
+  const swap_test_class initial_array2[dimension] = { swap_test_class(3), swap_test_class(4) };
+  
   swap_test_class array1[dimension];
   swap_test_class array2[dimension];
+
+  std::copy(initial_array1, initial_array1 + dimension, array1);
+  std::copy(initial_array2, initial_array2 + dimension, array2);
+  
+  swap_test_class::reset();
   boost::swap(array1, array2);
 
+  BOOST_CHECK(std::equal(array1, array1 + dimension, initial_array2));
+  BOOST_CHECK(std::equal(array2, array2 + dimension, initial_array1));
+
   BOOST_CHECK_EQUAL(swap_test_class::swap_count(), dimension);
   BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
+}
 
-  swap_test_class::reset();
 
-  const std::size_t firstDimension = 3;
-  const std::size_t secondDimension = 4;
+// Tests swapping 2-dimensional arrays.
+void test_swapping_2D_arrays()
+{
+  const std::size_t first_dimension = 3;
+  const std::size_t second_dimension = 4;
+  const std::size_t number_of_elements = first_dimension * second_dimension;
+
+  swap_test_class array1[first_dimension][second_dimension];
+  swap_test_class array2[first_dimension][second_dimension];
 
-  swap_test_class two_d_array1[firstDimension][secondDimension];
-  swap_test_class two_d_array2[firstDimension][secondDimension];
-  boost::swap(two_d_array1, two_d_array2);
+  swap_test_class* const ptr1 = array1[0];
+  swap_test_class* const ptr2 = array2[0];
 
-  BOOST_CHECK_EQUAL(swap_test_class::swap_count(), firstDimension*secondDimension);
+  for (std::size_t i = 0; i < number_of_elements; ++i)
+  {
+    ptr1[i].set_data( static_cast<int>(i) );
+    ptr2[i].set_data( static_cast<int>(i + number_of_elements) );
+  }
+
+  swap_test_class::reset();
+  boost::swap(array1, array2);
+
+  for (std::size_t i = 0; i < number_of_elements; ++i)
+  {
+    BOOST_CHECK_EQUAL(ptr1[i].get_data(), static_cast<int>(i + number_of_elements) );
+    BOOST_CHECK_EQUAL(ptr2[i].get_data(), static_cast<int>(i) );
+  }
+
+  BOOST_CHECK_EQUAL(swap_test_class::swap_count(), number_of_elements);
   BOOST_CHECK_EQUAL(swap_test_class::copy_count(), 0);
+}
+
+
+int test_main(int, char*[])
+{
+  test_swapping_1D_arrays();
+  test_swapping_2D_arrays();
 
   return 0;
 }