{

test::random_values<T> values;

self_assign_base(std::size_t count = 0) : values(count, test::limited_range)

{

}

typedef T data_type;

T init() const { return T(values.begin(), values.end()); }

void run(T& x) const

{

x = x;

DISABLE_EXCEPTIONS;

test::check_container(x, values);

test::check_equivalent_keys(x);

}

void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const

{

test::check_equivalent_keys(x);

}

{

test::random_values<T> x_values, y_values;

T x, y;

int t1;

int t2;

typedef typename T::hasher hasher;

typedef typename T::key_equal key_equal;

typedef typename T::allocator_type allocator_type;

assign_base(int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0)

: x_values(), y_values(),

x(0, hasher(tag1), key_equal(tag1), allocator_type(tag1)),

y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2)),

t1(tag1),

t2(tag2)

{

x.max_load_factor(mlf1);

y.max_load_factor(mlf2);

}

typedef T data_type;

T init() const { return T(x); }

void run(T& x1) const

{

x1 = y;

DISABLE_EXCEPTIONS;

test::check_container(x1, y_values);

test::check_equivalent_keys(x1);

}

void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x1) const

{

test::check_equivalent_keys(x1);

if (x1.hash_function() == hasher(t1)) {

BOOST_TEST(x1.key_eq() == key_equal(t1));

}

if (x1.hash_function() == hasher(t2)) {

BOOST_TEST(x1.key_eq() == key_equal(t2));

}

if (x1.key_eq() == key_equal(t1)) {

BOOST_TEST(x1.hash_function() == hasher(t1));

}

if (x1.key_eq() == key_equal(t2)) {

BOOST_TEST(x1.hash_function() == hasher(t2));

}

// If the container is empty at the point of the exception, the

// internal structure is hidden, this exposes it, at the cost of

// messing up the data.

if (x_values.size()) {

T& x2 = const_cast<T&>(x1);

x2.emplace(*x_values.begin());

test::check_equivalent_keys(x2);

}

}

{

assign_values(unsigned int count1, unsigned int count2, int tag1, int tag2,

test::random_generator gen = test::default_generator, float mlf1 = 1.0,

float mlf2 = 1.0)

: assign_base<T>(tag1, tag2, mlf1, mlf2)

{

this->x_values.fill(count1, gen);

this->y_values.fill(count2, gen);

this->x.insert(this->x_values.begin(), this->x_values.end());

this->y.insert(this->y_values.begin(), this->y_values.end());

}

{

assign_test5()

: assign_values<T>(5, 60, 0, 0, test::default_generator, 1.0f, 0.1f)

{

}

{

equivalent_test1() : assign_base<T>(0, 0)

{

test::random_values<T> x_values2(10);

this->x_values.insert(x_values2.begin(), x_values2.end());

this->x_values.insert(x_values2.begin(), x_values2.end());

test::random_values<T> y_values2(10);

this->y_values.insert(y_values2.begin(), y_values2.end());

this->y_values.insert(y_values2.begin(), y_values2.end());

this->x.insert(this->x_values.begin(), this->x_values.end());

this->y.insert(this->y_values.begin(), this->y_values.end());

}