container/test/expand_bwd_test_template.hpp

219 lines
7.8 KiB
C++

//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2006. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/container for documentation.
//
//////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_CONTAINER_TEST_ALLOCATION_TEST_TEMPLATE_HEADER
#define BOOST_CONTAINER_TEST_ALLOCATION_TEST_TEMPLATE_HEADER
#include <boost/container/detail/config_begin.hpp>
#include <vector>
#include <typeinfo>
#include <iostream>
#include "expand_bwd_test_allocator.hpp"
#include <boost/container/detail/algorithm.hpp> //equal()
#include "movable_int.hpp"
#include <boost/move/make_unique.hpp>
namespace boost { namespace container { namespace test {
//Function to check if both sets are equal
template <class Vector1, class Vector2>
bool CheckEqualVector(const Vector1 &vector1, const Vector2 &vector2)
{
if(vector1.size() != vector2.size())
return false;
return boost::container::algo_equal(vector1.begin(), vector1.end(), vector2.begin());
}
template<class Vector>
bool CheckUninitializedIsZero(const Vector & v)
{
typedef typename Vector::value_type value_type;
typename Vector::size_type sz = v.size();
typename Vector::size_type extra = v.capacity() - v.size();
value_type comp(0);
const value_type *holder = &v[0] + sz;
while(extra--){
if(*holder++ != comp)
return false;
}
return true;
}
//This function tests all the possible combinations when
//inserting data in a vector and expanding backwards
template<class VectorWithExpandBwdAllocator>
bool test_insert_with_expand_bwd()
{
typedef typename VectorWithExpandBwdAllocator::value_type value_type;
typedef std::vector<value_type> Vect;
const unsigned int MemorySize = 1000;
//Distance old and new buffer
const unsigned int Offset[] =
{ 350, 300, 250, 200, 150, 100, 150, 100,
150, 50, 50, 50 };
//Initial vector size
const unsigned int InitialSize[] =
{ 200, 200, 200, 200, 200, 200, 200, 200,
200, 200, 200, 200 };
//Size of the data to insert
const unsigned int InsertSize[] =
{ 100, 100, 100, 100, 100, 100, 200, 200,
300, 25, 100, 200 };
//Number of tests
const unsigned int Iterations = sizeof(InsertSize)/sizeof(int);
//Insert position
const int Position[] =
{ 0, 100, 200 };
for(unsigned int pos = 0; pos < sizeof(Position)/sizeof(Position[0]); ++pos){
if(!life_count<value_type>::check(0))
return false;
for(unsigned int iteration = 0; iteration < Iterations; ++iteration)
{
boost::movelib::unique_ptr<char[]> memptr =
boost::movelib::make_unique_definit<char[]>(MemorySize*sizeof(value_type));
value_type *memory = (value_type*)memptr.get();
std::vector<value_type> initial_data;
initial_data.resize(InitialSize[iteration]);
for(unsigned int i = 0; i < InitialSize[iteration]; ++i){
initial_data[i] = i;
}
if(!life_count<value_type>::check(InitialSize[iteration]))
return false;
Vect data_to_insert;
data_to_insert.resize(InsertSize[iteration]);
for(unsigned int i = 0; i < InsertSize[iteration]; ++i){
data_to_insert[i] = -i;
}
if(!life_count<value_type>::check(InitialSize[iteration]+InsertSize[iteration]))
return false;
expand_bwd_test_allocator<value_type> alloc
(memory, MemorySize, Offset[iteration]);
VectorWithExpandBwdAllocator vector(alloc);
vector.insert( vector.begin()
, initial_data.begin(), initial_data.end());
vector.insert( vector.begin() + Position[pos]
, data_to_insert.begin(), data_to_insert.end());
if(!life_count<value_type>::check(InitialSize[iteration]*2+InsertSize[iteration]*2))
return false;
initial_data.insert(initial_data.begin() + Position[pos]
, data_to_insert.begin(), data_to_insert.end());
//Now check that values are equal
if(!CheckEqualVector(vector, initial_data)){
std::cout << "test_assign_with_expand_bwd::CheckEqualVector failed." << std::endl
<< " Class: " << typeid(VectorWithExpandBwdAllocator).name() << std::endl
<< " Iteration: " << iteration << std::endl;
return false;
}
}
if(!life_count<value_type>::check(0))
return false;
}
return true;
}
//This function tests all the possible combinations when
//inserting data in a vector and expanding backwards
template<class VectorWithExpandBwdAllocator>
bool test_assign_with_expand_bwd()
{
typedef typename VectorWithExpandBwdAllocator::value_type value_type;
const unsigned int MemorySize = 200;
const unsigned int Offset[] = { 50, 50, 50};
const unsigned int InitialSize[] = { 25, 25, 25};
const unsigned int InsertSize[] = { 15, 35, 55};
const unsigned int Iterations = sizeof(InsertSize)/sizeof(int);
for(unsigned int iteration = 0; iteration <Iterations; ++iteration)
{
boost::movelib::unique_ptr<char[]> memptr =
boost::movelib::make_unique_definit<char[]>(MemorySize*sizeof(value_type));
value_type *memory = (value_type*)memptr.get();
//Create initial data
std::vector<value_type> initial_data;
initial_data.resize(InitialSize[iteration]);
for(unsigned int i = 0; i < InitialSize[iteration]; ++i){
initial_data[i] = i;
}
//Create data to assign
std::vector<value_type> data_to_insert;
data_to_insert.resize(InsertSize[iteration]);
for(unsigned int i = 0; i < InsertSize[iteration]; ++i){
data_to_insert[i] = -i;
}
//Insert initial data to the vector to test
expand_bwd_test_allocator<value_type> alloc
(memory, MemorySize, Offset[iteration]);
VectorWithExpandBwdAllocator vector(alloc);
vector.insert( vector.begin()
, initial_data.begin(), initial_data.end());
//Assign data
vector.insert(vector.cbegin(), data_to_insert.begin(), data_to_insert.end());
initial_data.insert(initial_data.begin(), data_to_insert.begin(), data_to_insert.end());
//Now check that values are equal
if(!CheckEqualVector(vector, initial_data)){
std::cout << "test_assign_with_expand_bwd::CheckEqualVector failed." << std::endl
<< " Class: " << typeid(VectorWithExpandBwdAllocator).name() << std::endl
<< " Iteration: " << iteration << std::endl;
return false;
}
}
return true;
}
//This function calls all tests
template<class VectorWithExpandBwdAllocator>
bool test_all_expand_bwd()
{
std::cout << "Starting test_insert_with_expand_bwd." << std::endl << " Class: "
<< typeid(VectorWithExpandBwdAllocator).name() << std::endl;
if(!test_insert_with_expand_bwd<VectorWithExpandBwdAllocator>()){
std::cout << "test_allocation_direct_deallocation failed. Class: "
<< typeid(VectorWithExpandBwdAllocator).name() << std::endl;
return false;
}
std::cout << "Starting test_assign_with_expand_bwd." << std::endl << " Class: "
<< typeid(VectorWithExpandBwdAllocator).name() << std::endl;
if(!test_assign_with_expand_bwd<VectorWithExpandBwdAllocator>()){
std::cout << "test_allocation_direct_deallocation failed. Class: "
<< typeid(VectorWithExpandBwdAllocator).name() << std::endl;
return false;
}
return true;
}
}}} //namespace boost { namespace container { namespace test {
#include <boost/container/detail/config_end.hpp>
#endif //BOOST_CONTAINER_TEST_ALLOCATION_TEST_TEMPLATE_HEADER