boost_mirror/utility
1
0
Fork 0
mirror of https://github.com/boostorg/utility.git synced 2025-05-09 02:44:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

Extended swap_arrays test, checking that boost::swap does correctly exchange the values of its arguments.

Browse Source 
[SVN r48247]
This commit is contained in:
Niels Dekker 2008-08-20 08:29:54 +00:00
parent 2cde009bb1
commit d264005c11
1 changed files with 52 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
swap/test/swap_arrays.cpp
View File

@ -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 @@ namespace std
}
}
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);
}
// 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* const ptr1 = array1[0];
swap_test_class* const ptr2 = array2[0];
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);
const std::size_t firstDimension = 3;
const std::size_t secondDimension = 4;
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) );
}
swap_test_class two_d_array1[firstDimension][secondDimension];
swap_test_class two_d_array2[firstDimension][secondDimension];
boost::swap(two_d_array1, two_d_array2);
BOOST_CHECK_EQUAL(swap_test_class::swap_count(), firstDimension*secondDimension);
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;
}