+2008-06-06 Benjamin Kosnik <bkoz@redhat.com>
+
+ * doc/xml/manual/using.xml: Outline exception topics.
+
+ * include/ext/pb_ds/detail/binary_heap_/insert_fn_imps.hpp: Format.
+ * include/ext/pb_ds/detail/left_child_next_sibling_heap_/
+ policy_access_fn_imps.hpp: Same.
+ * include/ext/pb_ds/priority_queue.hpp: Same.
+ * include/ext/throw_allocator.h: Same.
+
+ * include/ext/pb_ds/tag_and_trait.hpp (string_tag): New tag.
+ (sequence_tag): New tag. Doxygen markup fixes.
+
+ * testsuite/lib/libstdc++.exp: Remove twister_ran_gen.cc source file.
+
+ * testsuite/performance/ext/pb_ds/text_find_timing.cc: Fix
+ comment typo, include paths, format.
+ * testsuite/performance/ext/pb_ds/tree_text_insert_timing.cc: Same.
+ * testsuite/performance/ext/pb_ds/
+ hash_random_int_erase_mem_usage.cc: Same.
+ * testsuite/performance/ext/pb_ds/
+ random_int_subscript_find_timing.cc: Same.
+ * testsuite/performance/ext/pb_ds/
+ priority_queue_text_push_timing.cc: Same.
+ * testsuite/performance/ext/pb_ds/tree_split_join_timing.cc: Same.
+ * testsuite/performance/ext/pb_ds/random_int_find_timing.cc: Same.
+ * testsuite/performance/ext/pb_ds/multimap_text_insert_mem_usage.hpp
+ * testsuite/performance/ext/pb_ds/multimap_text_find_timing.hpp
+ * testsuite/performance/ext/pb_ds/
+ priority_queue_random_int_push_timing.cc: Same.
+ * testsuite/performance/ext/pb_ds/priority_queue_text_modify_timing.hpp
+ * testsuite/performance/ext/pb_ds/tree_order_statistics_timing.cc: Same.
+ * testsuite/performance/ext/pb_ds/
+ priority_queue_text_push_pop_timing.cc: Same.
+ * testsuite/performance/ext/pb_ds/
+ priority_queue_text_join_timing.cc: Same.
+ * testsuite/performance/ext/pb_ds/
+ priority_queue_random_int_push_pop_timing.cc: Same.
+ * testsuite/performance/ext/pb_ds/
+ random_int_subscript_insert_timing.cc: Same.
+ * testsuite/performance/ext/pb_ds/tree_text_lor_find_timing.cc: Same.
+ * testsuite/performance/ext/pb_ds/multimap_text_insert_timing.hpp
+ * testsuite/performance/ext/pb_ds/
+ priority_queue_text_pop_mem_usage.cc: Same.
+ * testsuite/performance/ext/pb_ds/
+ hash_zlob_random_int_find_timing.cc: Same.
+ * testsuite/ext/pb_ds/regression/hash_data_map_rand.cc: Same.
+ * testsuite/ext/pb_ds/regression/trie_data_map_rand.cc: Same.
+ * testsuite/ext/pb_ds/regression/list_update_no_data_map_rand.cc: Same.
+ * testsuite/ext/pb_ds/regression/tree_no_data_map_rand.cc: Same.
+ * testsuite/ext/pb_ds/regression/list_update_data_map_rand.cc: Same.
+ * testsuite/ext/pb_ds/regression/hash_no_data_map_rand.cc: Same.
+ * testsuite/ext/pb_ds/regression/priority_queue_rand.cc: Same.
+ * testsuite/ext/pb_ds/regression/tree_data_map_rand.cc: Same.
+ * testsuite/ext/pb_ds/regression/trie_no_data_map_rand.cc: Same.
+ * testsuite/util/regression/trait/priority_queue/trait.hpp: Same.
+ * testsuite/util/regression/trait/erase_if_fn.hpp: Same.
+ * testsuite/util/regression/trait/assoc/native_type_trait.hpp: Same.
+ * testsuite/util/regression/trait/assoc/node_update_trait.hpp: Same.
+ * testsuite/util/regression/trait/assoc/get_set_load_trait.hpp: Same.
+ * testsuite/util/regression/trait/assoc/get_set_loads_trait.hpp: Same.
+ * testsuite/util/regression/trait/assoc/trait.hpp: Same.
+ * testsuite/util/regression/trait/assoc/resize_trait.hpp: Same.
+ * testsuite/util/regression/trait/assoc/type_trait.hpp: Same.
+ * testsuite/util/regression/trait/assoc/to_string.hpp: Same.
+ * testsuite/util/regression/basic_type.hpp: Same.
+ * testsuite/util/common_type/priority_queue/string_form.hpp: Same.
+ * testsuite/util/common_type/priority_queue/detail/
+ ds_string_form.hpp: Same.
+ * testsuite/util/common_type/assoc/string_form.hpp: Same.
+ * testsuite/util/common_type/assoc/detail/
+ resize_policy_string_form.hpp: Same.
+ * testsuite/util/common_type/assoc/detail/
+ trigger_policy_string_form.hpp: Same.
+ * testsuite/util/common_type/assoc/detail/
+ comb_hash_fn_string_form.hpp: Same.
+ * testsuite/util/common_type/assoc/detail/ds_string_form.hpp: Same.
+ * testsuite/util/common_type/assoc/detail/
+ size_policy_string_form.hpp: Same.
+ * testsuite/util/common_type/assoc/detail/
+ probe_fn_string_form.hpp: Same.
+ * testsuite/util/common_type/assoc/detail/
+ list_update_policy_string_form.hpp: Same.
+ * testsuite/util/common_type/assoc/detail/
+ store_hash_string_form.hpp: Same.
+ * testsuite/util/common_type/assoc/native_set.hpp: Same.
+ * testsuite/util/io/prog_bar.cc: Same.
+
+ * testsuite/util/regression/rand/io: Remove.
+ * testsuite/util/regression/rand/io/priority_queue: Same.
+ * testsuite/util/regression/rand/io/assoc: Same.
+ * testsuite/util/regression/rand/io/priority_queue/
+ xml_formatter.hpp: Consolidate this...
+ * testsuite/util/regression/rand/io/assoc/xml_formatter.hpp: ...this
+ * testsuite/util/regression/rand/io/xml_formatter.hpp: ... and this
+ * testsuite/util/regression/rand/xml_formatter.hpp: ...here.
+
+ * testsuite/util/regression/rand/priority_queue/
+ container_rand_regression_test.hpp:To ...
+ container_rand_regression_test.h: ... this.
+ * testsuite/util/regression/rand/priority_queue/detail/*.hpp:To ...
+ * testsuite/util/regression/rand/priority_queue/
+ container_rand_regression_test.tcc: ... this.
+ PB_DS_THROW_IF_FAIL: Change to _GLIBCXX_THROW_IF, adjust predicate.
+ PB_DS_SET_DESTRUCT_PRINT: Fold inline.
+ PB_DS_CANCEL_DESTRUCT_PRINT: Fold inline.
+ * testsuite/util/regression/rand/priority_queue/
+ rand_regression_test.hpp: Adjust includes.
+
+ * testsuite/util/regression/rand/assoc/
+ container_rand_regression_test.hpp: To ...
+ * testsuite/util/regression/rand/assoc/
+ container_rand_regression_test.h: ... this.
+ * testsuite/util/regression/rand/assoc/detail/*.hpp:To ...
+ * testsuite/util/regression/rand/assoc/
+ container_rand_regression_test.tcc: ...this.
+ * testsuite/util/regression/rand/assoc/rand_regression_test.hpp: Adjust
+ includes.
+
+ * testsuite/util/regression/priority_queue: Remove.
+ * testsuite/util/regression/assoc: Remove.
+ * testsuite/util/regression/priority_queue/
+ common_type.hpp: Consolidate this...
+ * testsuite/util/regression/assoc/common_type.hpp: ... and this
+ * testsuite/util/regression/common_type.hpp: ...here.
+
+ * testsuite/util/rng: Remove.
+ * testsuite/util/rng/twister_rand_gen.cc: Consolidate...
+ * testsuite/util/rng/twister_rand_gen.hpp: ... and this
+ * testsuite/util/testsuite_rng.h: ...here.
+
+ * testsuite/util/native_type/priority_queue: Remove.
+ * testsuite/util/native_type/priority_queue/
+ native_priority_queue.hpp: To...
+ * testsuite/util/native_type/native_priority_queue.hpp: ...here.
+
+ * testsuite/util/native_type/assoc: Remove.
+ * testsuite/util/native_type/assoc/native_multimap.hpp: To...
+ * testsuite/util/native_type/assoc/native_tree_tag.hpp: To...
+ * testsuite/util/native_type/assoc/native_hash_multimap.hpp: To...
+ * testsuite/util/native_type/assoc/native_set.hpp: To...
+ * testsuite/util/native_type/assoc/native_map.hpp: To...
+ * testsuite/util/native_type/assoc/native_hash_set.hpp: To...
+ * testsuite/util/native_type/assoc/native_hash_tag.hpp: To...
+ * testsuite/util/native_type/assoc/native_hash_map.hpp: To...
+ * testsuite/util/native_type/native_multimap.hpp: ...here.
+ * testsuite/util/native_type/native_tree_tag.hpp: ...here.
+ * testsuite/util/native_type/native_hash_multimap.hpp: ...here.
+ * testsuite/util/native_type/native_set.hpp: ...here.
+ * testsuite/util/native_type/native_map.hpp: ...here.
+ * testsuite/util/native_type/native_hash_set.hpp: ...here.
+ * testsuite/util/native_type/native_hash_tag.hpp: ...here.
+ * testsuite/util/native_type/native_hash_map.hpp: ...here.
+
+ * testsuite/util/common_type/priority_queue/common_type.hpp:
+ Make include guard distinct.
+ * testsuite/util/common_type/assoc/common_type.hpp: Same.
+
2008-06-06 Joseph Myers <joseph@codesourcery.com>
* configure.ac: Do not check for gconv.h.
2008-06-05 Johannes Singler <singler@ira.uka.de>
- * include/parallel/random_shuffle.h:
- (parallel_random_shuffle_drs) Get the actual number of
- threads after entering the parallel region. Indentation.
- * include/parallel/algo.h: (random_shuffle(begin, end))
- Add namespace qualification to avoid ambiguity.
+ * include/parallel/random_shuffle.h:
+ (parallel_random_shuffle_drs) Get the actual number of
+ threads after entering the parallel region. Indentation.
+ * include/parallel/algo.h: (random_shuffle(begin, end))
+ Add namespace qualification to avoid ambiguity.
2008-06-04 Benjamin Kosnik <bkoz@redhat.com>
* include/ext/pb_ds/assoc_container.hpp: Change allocator typedef
- to allocator_type, as per existing conventions.
+ to allocator_type, as per existing conventions.
* include/ext/pb_ds/detail/binomial_heap_base_/
binomial_heap_base_.hpp: Same.
* include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp: Same.
trie_supports_prefix_search.hpp: Same.
* testsuite/util/common_type/assoc/detail/
trie_supports_order_statistics.hpp: Same.
-
+
2008-06-02 Sandra Loosemore <sandra@codesourcery.com>
Daniel Jacobowitz <dan@codesourcery.com>
dg-require-fileio.
* testsuite/27_io/basic_filebuf/sputbackc/char/1-out.cc: Likewise.
* testsuite/27_io/basic_filebuf/sputbackc/char/2-out.cc: Likewise.
-
+
2008-06-02 Paolo Carlini <paolo.carlini@oracle.com>
* include/bits/vector.tcc (vector<>::_M_insert_aux): In C++0x mode,
2008-05-23 Paolo Carlini <paolo.carlini@oracle.com>
- * include/std/tuple: Replace int -> size_t throughout per DR 775.
+ * include/std/tuple: Replace int -> size_t throughout per DR 775.
* include/tr1_impl/array: Likewise.
* include/tr1_impl/utility: Likewise.
* doc/xml/manual/intro.xml: Add an entry for DR 775.
2008-05-22 Paolo Carlini <paolo.carlini@oracle.com>
* include/tr1_impl/hashtable_policy.h (_Map_base<,,
- std::_Select1st<_Pair>, true,>::at): Add per DR 761.
+ std::_Select1st<_Pair>, true,>::at): Add per DR 761.
* testsuite/23_containers/unordered_map/dr761.cc: New.
* doc/xml/manual/intro.xml: Add an entry for DR 761.
* testsuite/20_util/is_integral/requirements/typedefs.cc: Likewise.
* testsuite/20_util/is_integral/requirements/
explicit_instantiation.cc: Likewise.
- * testsuite/18_support/numeric_limits/char16_32_t.cc: Likewise.
+ * testsuite/18_support/numeric_limits/char16_32_t.cc: Likewise.
* config/abi/pre/gnu.ver: Export new numeric_limits symbols at
GLIBCXX_3.4.11.
* configure: Regenerate.
* include/std/ostream: Adjust error_code inserter.
* acinclude.m4 (GLIBCXX_CHECK_SYSTEM_ERROR): Remove sys_nerr test.
* config/abi/pre/gnu.ver: Add new exports.
-
+
* testsuite/util/testsuite_error.h: Consolidate error testing
utilities here.
* testsuite/19_diagnostics/error_code/cons/1.cc: Use
* testsuite/19_diagnostics/error_category/cons/default.cc: Same.
* testsuite/19_diagnostics/error_category/operators/equal.cc: Same.
* testsuite/19_diagnostics/error_category/operators/not_equal.cc: Same.
- * testsuite/19_diagnostics/system_error/cons_virtual_derivation.cc:
+ * testsuite/19_diagnostics/system_error/cons_virtual_derivation.cc:
Same.
* testsuite/19_diagnostics/system_error/cons-1.cc: Same.
* testsuite/19_diagnostics/system_error/what-1.cc: Same.
2008-05-15 Johannes Singler <singler@ira.uka.de>
- * xml/manual/parallel_mode.xml:
- General revision and documentation of new compile-time
- options for sorting.
+ * xml/manual/parallel_mode.xml:
+ General revision and documentation of new compile-time
+ options for sorting.
2008-05-14 Benjamin Kosnik <bkoz@redhat.com>
* testsuite/29_atomics/atomic_flag/test_and_set/implicit.c: Same.
* doc/doxygen/user.cfg.in: Remove thread include.
-
+
2008-05-13 David Daney <ddaney@avtrex.com>
* config/cpu/mips/atomicity.h: Remove file.
* include/parallel/quicksort.h:
(parallel_sort_qs_conquer) Explicitly request number of threads
in the parallel clause.
- (parallel_sort_qs) Remove setting the number of threads globally.
+ (parallel_sort_qs) Remove setting the number of threads globally.
2008-05-06 Benjamin Kosnik <bkoz@redhat.com>
* testsuite/30_threads/mutex/cons/copy_neg.cc: Same.
* testsuite/30_threads/recursive_mutex/cons/assign_neg.cc: Same.
* testsuite/30_threads/recursive_mutex/cons/copy_neg.cc: Same.
-
+
2008-05-06 Benjamin Kosnik <bkoz@redhat.com>
* include/std/condition_variable: New.
</sect2>
</sect1>
- <sect1 id="manual.intro.using.exception_safety" xreflabel="Exception Safety">
- <title>Exception Safety</title>
+ <sect1 id="manual.intro.using.exception" xreflabel="Exceptions">
+ <title>Exceptions</title>
<para></para>
+
+ <sect2 id="intro.using.exception.propagating" xreflabel="Propagating Exceptions">
+ <title>Propagating Exceptions aka Exception Neutrality</title>
+ </sect2>
+
+ <sect2 id="intro.using.exception.safety" xreflabel="Exception Safety">
+ <title>Exception Safety</title>
+ </sect2>
+
+ <sect2 id="intro.using.exception.no" xreflabel="no-exceptions">
+ <title>Support for <literal>-fno-exceptions</literal></title>
+ </sect2>
+
</sect1>
<!-- Section 0x : Debug -->
push(const_reference r_val)
{
_GLIBCXX_DEBUG_ONLY(assert_valid();)
-
- insert_value(r_val, s_no_throw_copies_ind);
-
- std::push_heap(m_a_entries, m_a_entries + m_size, static_cast<entry_cmp& >(*this));
-
+ insert_value(r_val, s_no_throw_copies_ind);
+ std::push_heap(m_a_entries, m_a_entries + m_size,
+ static_cast<entry_cmp&>(*this));
_GLIBCXX_DEBUG_ONLY(assert_valid();)
-
- return point_iterator(m_a_entries);
+ return point_iterator(m_a_entries);
}
PB_DS_CLASS_T_DEC
insert_value(const_reference r_val, false_type)
{
resize_for_insert_if_needed();
-
pointer p_new = s_value_allocator.allocate(1);
-
cond_dealtor_t cond(p_new);
-
new (p_new) value_type(r_val);
-
cond.set_no_action();
-
m_a_entries[m_size++] = p_new;
}
insert_entry(entry e)
{
resize_for_insert_if_needed();
-
m_a_entries[m_size++] = e;
}
if (!resize_policy::resize_needed_for_grow(m_size))
{
_GLIBCXX_DEBUG_ASSERT(m_size < m_actual_size);
-
return;
}
- const size_type new_actual_size =
- resize_policy::get_new_size_for_grow();
-
+ const size_type new_actual_size = resize_policy::get_new_size_for_grow();
entry_pointer a_new_entries = s_entry_allocator.allocate(new_actual_size);
-
resize_policy::notify_grow_resize();
-
std::copy(m_a_entries, m_a_entries + m_size, a_new_entries);
-
s_entry_allocator.deallocate(m_a_entries, m_actual_size);
-
m_actual_size = new_actual_size;
-
m_a_entries = a_new_entries;
}
modify(point_iterator it, const_reference r_new_val)
{
_GLIBCXX_DEBUG_ONLY(assert_valid();)
-
- swap_value_imp(it.m_p_e, r_new_val, s_no_throw_copies_ind);
-
+ swap_value_imp(it.m_p_e, r_new_val, s_no_throw_copies_ind);
fix(it.m_p_e);
-
_GLIBCXX_DEBUG_ONLY(assert_valid();)
- }
+}
PB_DS_CLASS_T_DEC
void
fix(entry_pointer p_e)
{
size_type i = p_e - m_a_entries;
-
- if (i > 0&& entry_cmp::operator()(m_a_entries[parent(i)], m_a_entries[i]))
+ if (i > 0 && entry_cmp::operator()(m_a_entries[parent(i)], m_a_entries[i]))
{
size_type parent_i = parent(i);
-
- while (i > 0&& entry_cmp::operator()(m_a_entries[parent_i], m_a_entries[i]))
+ while (i > 0
+ && entry_cmp::operator()(m_a_entries[parent_i], m_a_entries[i]))
{
std::swap(m_a_entries[i], m_a_entries[parent_i]);
-
i = parent_i;
-
parent_i = parent(i);
}
_GLIBCXX_DEBUG_ONLY(assert_valid();)
-
- return;
+ return;
}
while (i < m_size)
{
const size_type left_child_i = left_child(i);
const size_type right_child_i = right_child(i);
-
_GLIBCXX_DEBUG_ASSERT(right_child_i > left_child_i);
-
- const bool smaller_than_left_child =
- left_child_i < m_size&&
+ const bool smaller_than_left_child = left_child_i < m_size &&
entry_cmp::operator()(m_a_entries[i], m_a_entries[left_child_i]);
- const bool smaller_than_right_child =
- right_child_i < m_size&&
+ const bool smaller_than_right_child = right_child_i < m_size &&
entry_cmp::operator()(m_a_entries[i], m_a_entries[right_child_i]);
- const bool swap_with_r_child = smaller_than_right_child&& (!smaller_than_left_child ||
- entry_cmp::operator()(m_a_entries[left_child_i], m_a_entries[right_child_i]));
+ const bool swap_with_r_child = smaller_than_right_child && (!smaller_than_left_child || entry_cmp::operator()(m_a_entries[left_child_i], m_a_entries[right_child_i]));
- const bool swap_with_l_child = !swap_with_r_child&& smaller_than_left_child;
+ const bool swap_with_l_child = !swap_with_r_child && smaller_than_left_child;
if (swap_with_l_child)
{
std::swap(m_a_entries[i], m_a_entries[left_child_i]);
-
i = left_child_i;
}
else if (swap_with_r_child)
{
std::swap(m_a_entries[i], m_a_entries[right_child_i]);
-
i = right_child_i;
}
else
Cmp_Fn&
PB_DS_CLASS_C_DEC::
get_cmp_fn()
-{
- return (*this);
-}
+{ return *this; }
PB_DS_CLASS_T_DEC
const Cmp_Fn&
PB_DS_CLASS_C_DEC::
get_cmp_fn() const
-{
- return (*this);
-}
+{ return *this; }
typename Tag = pairing_heap_tag,
typename Allocator = std::allocator<char> >
class priority_queue
- : public detail::priority_queue_base_dispatch<Value_Type,Cmp_Fn,Tag,Allocator>::type
+ : public detail::priority_queue_base_dispatch<Value_Type,Cmp_Fn,Tag,Allocator>::type
{
private:
typedef typename detail::priority_queue_base_dispatch<Value_Type,Cmp_Fn,Tag,Allocator>::type base_type;
priority_queue&
operator=(const priority_queue& other)
{
- if (this !=& other)
+ if (this != &other)
{
priority_queue tmp(other);
swap(tmp);
// -*- C++ -*-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2008 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the terms
{ };
- // A mapped-policy indicating that an associative container is a set.
+ /// A mapped-policy indicating that an associative container is a set.
// XXX should this be a trait of the form is_set<T> ??
struct null_mapped_type { };
- // Base data structure tag.
+ /// Base data structure tag.
struct container_tag
{ };
- // Basic associative-container.
+ /// Basic string container, inclusive of strings, ropes, etc.
+ struct string_tag : public container_tag { };
+
+ /// Basic sequence.
+ struct sequence_tag : public container_tag { };
+
+ /// Basic associative-container.
struct associative_container_tag : public container_tag { };
- // Basic hash.
+ /// Basic hash.
struct basic_hash_tag : public associative_container_tag { };
- // Collision-chaining hash.
+ /// Collision-chaining hash.
struct cc_hash_tag : public basic_hash_tag { };
- // General-probing hash.
+ /// General-probing hash.
struct gp_hash_tag : public basic_hash_tag { };
- // Basic tree.
+ /// Basic tree.
struct basic_tree_tag : public associative_container_tag { };
- // tree.
+ /// tree.
struct tree_tag : public basic_tree_tag { };
- // Red-black tree.
+ /// Red-black tree.
struct rb_tree_tag : public tree_tag { };
- // Splay tree.
+ /// Splay tree.
struct splay_tree_tag : public tree_tag { };
- // Ordered-vector tree.
+ /// Ordered-vector tree.
struct ov_tree_tag : public tree_tag { };
- // trie.
+ /// trie.
struct trie_tag : public basic_tree_tag { };
- // PATRICIA trie.
+ /// PATRICIA trie.
struct pat_trie_tag : public trie_tag { };
- // List-update.
+ /// List-update.
struct list_update_tag : public associative_container_tag { };
- // Basic priority-queue.
+ /// Basic priority-queue.
struct priority_queue_tag : public container_tag { };
- // Pairing-heap.
+ /// Pairing-heap.
struct pairing_heap_tag : public priority_queue_tag { };
- // Binomial-heap.
+ /// Binomial-heap.
struct binomial_heap_tag : public priority_queue_tag { };
- // Redundant-counter binomial-heap.
+ /// Redundant-counter binomial-heap.
struct rc_binomial_heap_tag : public priority_queue_tag { };
- // Binary-heap (array-based).
+ /// Binary-heap (array-based).
struct binary_heap_tag : public priority_queue_tag { };
- // Thin heap.
+ /// Thin heap.
struct thin_heap_tag : public priority_queue_tag { };
+ /// Base traits type for containers.
template<typename Tag>
struct container_traits_base;
};
};
-
+
+ /// container_traits
// See Matt Austern for the name, S. Meyers MEFC++ #2, others.
template<typename Cntnr>
struct container_traits
_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
class twister_rand_gen
- {
+ {
+ private:
+ std::tr1::mt19937 _M_generator;
+
public:
- twister_rand_gen(unsigned int seed =
- static_cast<unsigned int>(std::time(0)));
+ twister_rand_gen(unsigned int s = static_cast<unsigned int>(std::time(0)));
void
init(unsigned int);
double
get_prob();
-
- private:
- std::tr1::mt19937 _M_generator;
};
/// Thown by throw_allocator.
struct group_throw_prob_adjustor
{
- group_throw_prob_adjustor(size_t size)
- : _M_throw_prob_orig(_S_throw_prob)
+ group_throw_prob_adjustor(size_t size) : _M_throw_prob_orig(_S_throw_prob)
{
_S_throw_prob =
1 - std::pow(double(1 - _S_throw_prob), double(0.5 / (size + 1)));
twister_rand_gen::
get_prob()
{
- const double eng_min = _M_generator.min();
- const double eng_range =
- static_cast<const double>(_M_generator.max() - eng_min);
-
- const double eng_res =
- static_cast<const double>(_M_generator() - eng_min);
-
- const double ret = eng_res / eng_range;
+ const double min = _M_generator.min();
+ const double res = static_cast<const double>(_M_generator() - min);
+ const double range = static_cast<const double>(_M_generator.max() - min);
+ const double ret = res / range;
_GLIBCXX_DEBUG_ASSERT(ret >= 0 && ret <= 1);
return ret;
}
while (it != _S_map.end())
{
if (it->second.first == label)
- print_to_string(found, *it);
+ {
+ print_to_string(found, *it);
+ }
++it;
}
// { dg-require-time "" }
#include <regression/rand/assoc/rand_regression_test.hpp>
-#include <regression/assoc/common_type.hpp>
+#include <regression/common_type.hpp>
// This can take long on simulators, timing out the test.
// { dg-options "-DPB_DS_REGRESSION -DITERATIONS=5" { target simulator } }
// { dg-require-time "" }
#include <regression/rand/assoc/rand_regression_test.hpp>
-#include <regression/assoc/common_type.hpp>
+#include <regression/common_type.hpp>
// This can take long on simulators, timing out the test.
// { dg-options "-DPB_DS_REGRESSION -DITERATIONS=5" { target simulator } }
// { dg-require-time "" }
#include <regression/rand/assoc/rand_regression_test.hpp>
-#include <regression/assoc/common_type.hpp>
+#include <regression/common_type.hpp>
int
main(int argc, char* a_p_argv[])
// { dg-require-time "" }
#include <regression/rand/assoc/rand_regression_test.hpp>
-#include <regression/assoc/common_type.hpp>
+#include <regression/common_type.hpp>
int
main(int argc, char* a_p_argv[])
// { dg-require-time "" }
#include <regression/rand/priority_queue/rand_regression_test.hpp>
-#include <regression/priority_queue/common_type.hpp>
+#include <regression/common_type.hpp>
// This can take long on simulators, timing out the test.
// { dg-options "-DPB_DS_REGRESSION -DITERATIONS=5" { target simulator } }
{
using namespace __gnu_pbds::test;
return rand_regression_test(ITERATIONS, KEYS,
- "tree_no_data_map_rand_regression_test",
+ "pq_no_data_map_rand_regression_test",
pq_tl_t());
}
// { dg-require-time "" }
#include <regression/rand/assoc/rand_regression_test.hpp>
-#include <regression/assoc/common_type.hpp>
+#include <regression/common_type.hpp>
// This can take long on simulators, timing out the test.
// { dg-options "-DPB_DS_REGRESSION -DITERATIONS=5" { target simulator } }
// { dg-require-time "" }
#include <regression/rand/assoc/rand_regression_test.hpp>
-#include <regression/assoc/common_type.hpp>
+#include <regression/common_type.hpp>
// This can take long on simulators, timing out the test.
// { dg-options "-DPB_DS_REGRESSION -DITERATIONS=5" { target simulator } }
// { dg-require-time "" }
#include <regression/rand/assoc/rand_regression_test.hpp>
-#include <regression/assoc/common_type.hpp>
+#include <regression/common_type.hpp>
// This can take long on simulators, timing out the test.
// { dg-options "-DPB_DS_REGRESSION -DITERATIONS=5" { target simulator } }
// { dg-require-time "" }
#include <regression/rand/assoc/rand_regression_test.hpp>
-#include <regression/assoc/common_type.hpp>
+#include <regression/common_type.hpp>
// This can take long on simulators, timing out the test.
// { dg-options "-DPB_DS_REGRESSION -DITERATIONS=5" { target simulator } }
# Build the support objects.
set source_files [list testsuite_abi.cc testsuite_allocator.cc \
testsuite_character.cc testsuite_hooks.cc \
- rng/twister_rand_gen.cc io/verified_cmd_line_input.cc \
+ io/verified_cmd_line_input.cc \
io/prog_bar.cc performance/time/elapsed_timer.cc ]
foreach f $source_files {
set obj [file rootname $f].o
#include <testsuite_allocator.h>
#include <performance/io/xml_formatter.hpp>
#include <io/verified_cmd_line_input.hpp>
-#include <rng/twister_rand_gen.hpp>
+#include <testsuite_rng.h>
#include <common_type/assoc/common_type.hpp>
#include <performance/assoc/mem_usage/erase_test.hpp>
#include <iostream>
#include <ext/typelist.h>
#include <performance/io/xml_formatter.hpp>
-#include <native_type/assoc/native_hash_set.hpp>
+#include <native_type/native_hash_set.hpp>
#include <io/verified_cmd_line_input.hpp>
-#include <rng/twister_rand_gen.hpp>
+#include <testsuite_rng.h>
#include <common_type/assoc/common_type.hpp>
#include <performance/assoc/timing/find_test.hpp>
#include <iostream>
#include <ext/typelist.h>
#include <io/text_populate.hpp>
#include <performance/io/xml_formatter.hpp>
-#include <native_type/assoc/native_hash_multimap.hpp>
-#include <native_type/assoc/native_multimap.hpp>
+#include <native_type/native_hash_multimap.hpp>
+#include <native_type/native_multimap.hpp>
#include <io/verified_cmd_line_input.hpp>
-#include <rng/twister_rand_gen.hpp>
+#include <testsuite_rng.h>
#include <common_type/assoc/common_type.hpp>
#include <performance/assoc/timing/multimap_find_test.hpp>
#include <performance/assoc/multimap_common_type.hpp>
#include <testsuite_allocator.h>
#include <io/text_populate.hpp>
#include <performance/io/xml_formatter.hpp>
-#include <native_type/assoc/native_hash_multimap.hpp>
-#include <native_type/assoc/native_multimap.hpp>
+#include <native_type/native_hash_multimap.hpp>
+#include <native_type/native_multimap.hpp>
#include <io/verified_cmd_line_input.hpp>
-#include <rng/twister_rand_gen.hpp>
+#include <testsuite_rng.h>
#include <common_type/assoc/common_type.hpp>
#include <performance/assoc/mem_usage/multimap_insert_test.hpp>
#include <performance/assoc/multimap_common_type.hpp>
#include <ext/typelist.h>
#include <io/text_populate.hpp>
#include <performance/io/xml_formatter.hpp>
-#include <native_type/assoc/native_hash_multimap.hpp>
-#include <native_type/assoc/native_multimap.hpp>
+#include <native_type/native_hash_multimap.hpp>
+#include <native_type/native_multimap.hpp>
#include <io/verified_cmd_line_input.hpp>
-#include <rng/twister_rand_gen.hpp>
+#include <testsuite_rng.h>
#include <common_type/assoc/common_type.hpp>
#include <performance/assoc/timing/multimap_insert_test.hpp>
#include <performance/assoc/multimap_common_type.hpp>
#include <io/verified_cmd_line_input.hpp>
#include <common_type/priority_queue/common_type.hpp>
#include <performance/priority_queue/timing/push_pop_test.hpp>
-#include <native_type/priority_queue/native_priority_queue.hpp>
-#include <rng/twister_rand_gen.hpp>
+#include <native_type/native_priority_queue.hpp>
+#include <testsuite_rng.h>
#include <iostream>
#include <vector>
#include <io/verified_cmd_line_input.hpp>
#include <common_type/priority_queue/common_type.hpp>
#include <performance/priority_queue/timing/push_test.hpp>
-#include <native_type/priority_queue/native_priority_queue.hpp>
-#include <rng/twister_rand_gen.hpp>
+#include <native_type/native_priority_queue.hpp>
+#include <testsuite_rng.h>
#include <iostream>
#include <vector>
#include <common_type/priority_queue/common_type.hpp>
#include <performance/priority_queue/timing/join_test.hpp>
#include <io/text_populate.hpp>
-#include <native_type/priority_queue/native_priority_queue.hpp>
+#include <native_type/native_priority_queue.hpp>
#include <iostream>
#include <vector>
#include <common_type/priority_queue/common_type.hpp>
#include <performance/priority_queue/timing/modify_test.hpp>
#include <io/text_populate.hpp>
-#include <native_type/priority_queue/native_priority_queue.hpp>
+#include <native_type/native_priority_queue.hpp>
#include <iostream>
#include <vector>
#include <common_type/priority_queue/common_type.hpp>
#include <performance/priority_queue/mem_usage/pop_test.hpp>
#include <io/text_populate.hpp>
-#include <native_type/priority_queue/native_priority_queue.hpp>
+#include <native_type/native_priority_queue.hpp>
void
usage();
#include <common_type/priority_queue/common_type.hpp>
#include <performance/priority_queue/timing/push_pop_test.hpp>
#include <io/text_populate.hpp>
-#include <native_type/priority_queue/native_priority_queue.hpp>
+#include <native_type/native_priority_queue.hpp>
#include <iostream>
#include <vector>
#include <common_type/priority_queue/common_type.hpp>
#include <performance/priority_queue/timing/push_test.hpp>
#include <io/text_populate.hpp>
-#include <native_type/priority_queue/native_priority_queue.hpp>
+#include <native_type/native_priority_queue.hpp>
#include <iostream>
#include <vector>
#include <ext/typelist.h>
#include <performance/io/xml_formatter.hpp>
-#include <native_type/assoc/native_hash_map.hpp>
-#include <native_type/assoc/native_map.hpp>
+#include <native_type/native_hash_map.hpp>
+#include <native_type/native_map.hpp>
#include <io/verified_cmd_line_input.hpp>
-#include <rng/twister_rand_gen.hpp>
+#include <testsuite_rng.h>
#include <common_type/assoc/common_type.hpp>
#include <performance/assoc/timing/find_test.hpp>
#include <iostream>
#include <ext/typelist.h>
#include <performance/io/xml_formatter.hpp>
-#include <native_type/assoc/native_hash_map.hpp>
-#include <native_type/assoc/native_map.hpp>
+#include <native_type/native_hash_map.hpp>
+#include <native_type/native_map.hpp>
#include <io/verified_cmd_line_input.hpp>
-#include <rng/twister_rand_gen.hpp>
+#include <testsuite_rng.h>
#include <common_type/assoc/common_type.hpp>
#include <performance/assoc/timing/subscript_find_test.hpp>
#include <iostream>
#include <ext/typelist.h>
#include <performance/io/xml_formatter.hpp>
-#include <native_type/assoc/native_hash_map.hpp>
-#include <native_type/assoc/native_map.hpp>
+#include <native_type/native_hash_map.hpp>
+#include <native_type/native_map.hpp>
#include <io/verified_cmd_line_input.hpp>
-#include <rng/twister_rand_gen.hpp>
+#include <testsuite_rng.h>
#include <common_type/assoc/common_type.hpp>
#include <performance/assoc/timing/subscript_insert_test.hpp>
#include <iostream>
#include <performance/assoc/timing/find_test.hpp>
#include <io/text_populate.hpp>
#include <hash_fn/string_hash_fn.hpp>
-#include <native_type/assoc/native_hash_map.hpp>
-#include <native_type/assoc/native_map.hpp>
+#include <native_type/native_hash_map.hpp>
+#include <native_type/native_map.hpp>
#include <iostream>
#include <vector>
#include <ext/typelist.h>
#include <performance/io/xml_formatter.hpp>
#include <io/verified_cmd_line_input.hpp>
-#include <rng/twister_rand_gen.hpp>
+#include <testsuite_rng.h>
#include <common_type/assoc/common_type.hpp>
#include <performance/assoc/timing/tree_order_statistics_test.hpp>
#include <ext/typelist.h>
#include <performance/io/xml_formatter.hpp>
#include <io/verified_cmd_line_input.hpp>
-#include <rng/twister_rand_gen.hpp>
+#include <testsuite_rng.h>
#include <common_type/assoc/common_type.hpp>
#include <performance/assoc/timing/tree_split_join_test.hpp>
#include <iostream>
#include <performance/assoc/timing/insert_test.hpp>
#include <io/text_populate.hpp>
#include <hash_fn/string_hash_fn.hpp>
-#include <native_type/assoc/native_hash_map.hpp>
-#include <native_type/assoc/native_map.hpp>
+#include <native_type/native_hash_map.hpp>
+#include <native_type/native_map.hpp>
#include <iostream>
#include <vector>
#include <common_type/assoc/common_type.hpp>
#include <performance/assoc/timing/find_test.hpp>
#include <io/text_populate.hpp>
-#include <native_type/assoc/native_map.hpp>
+#include <native_type/native_map.hpp>
#include <iostream>
#include <vector>
* Contains common types.
*/
-#ifndef PB_DS_COMMON_TYPES_HPP
-#define PB_DS_COMMON_TYPES_HPP
+#ifndef PB_DS_COMMON_TYPES_ASSOC_HPP
+#define PB_DS_COMMON_TYPES_ASSOC_HPP
#include <ext/pb_ds/detail/type_utils.hpp>
#include <common_type/assoc/template_policy.hpp>
};
} // namespace test
-
} // namespace __gnu_pbds
-#endif // #ifndef PB_DS_COMMON_TYPES_HPP
+#endif // #ifndef PB_DS_COMMON_TYPES_ASSOC_HPP
namespace __gnu_pbds
{
+namespace test
+{
+namespace detail
+{
- namespace test
+ template<typename Comb_Hash_Fn>
+ struct comb_hash_fn_string_form
+ {
+ static std::string
+ name()
+ { return (Comb_Hash_Fn::name()); }
+
+ static std::string
+ desc()
+ { return (Comb_Hash_Fn::desc()); }
+ };
+
+ template<typename Size_Type>
+ struct comb_hash_fn_string_form<
+ direct_mask_range_hashing_t_<
+ Size_Type> >
{
+ static std::string
+ name()
+ { return ("mask_"); }
- namespace detail
+ static std::string
+ desc()
{
+ return make_xml_tag("Comb_Hash_Fn", "value", "direct_mask_range_hashing");
+ }
+ };
- template<typename Comb_Hash_Fn>
- struct comb_hash_fn_string_form
- {
- static std::string
- name()
- {
- return (Comb_Hash_Fn::name());
- }
-
- static std::string
- desc()
- {
- return (Comb_Hash_Fn::desc());
- }
- };
-
- template<typename Size_Type>
- struct comb_hash_fn_string_form<
- direct_mask_range_hashing_t_<
- Size_Type> >
- {
- static std::string
- name()
- {
- return ("mask_");
- }
-
- static std::string
- desc()
- {
- return (make_xml_tag( "Comb_Hash_Fn", "value", "direct_mask_range_hashing"));
- }
- };
-
- template<typename Size_Type>
- struct comb_hash_fn_string_form<
- direct_mod_range_hashing_t_<
- Size_Type> >
- {
- static std::string
- name()
- {
- return ("mod_");
- }
-
- static std::string
- desc()
- {
- return (make_xml_tag( "Comb_Hash_Fn", "value", "direct_mod_range_hashing"));
- }
- };
-
- } // namespace detail
-
- } // namespace test
+ template<typename Size_Type>
+ struct comb_hash_fn_string_form<direct_mod_range_hashing_t_<Size_Type> >
+ {
+ static std::string
+ name()
+ { return ("mod_"); }
+
+ static std::string
+ desc()
+ {
+ return make_xml_tag("Comb_Hash_Fn", "value", "direct_mod_range_hashing");
+ }
+ };
+} // namespace detail
+} // namespace test
} // namespace __gnu_pbds
#endif // #ifndef PB_DS_COMB_HASH_FN_STRING_FORM_HPP
namespace __gnu_pbds
{
-
namespace test
{
-
namespace detail
{
-
template<typename Cntnr, class Tag>
struct ds_string_form;
template<typename Cntnr>
- struct ds_string_form<
- Cntnr,
- __gnu_pbds::cc_hash_tag>
+ struct ds_string_form<Cntnr, __gnu_pbds::cc_hash_tag>
{
static std::string
name()
const std::string store_hash_desc =
store_hash_string_form<Cntnr::store_hash>::desc();
- return (make_xml_tag( "type", "value", "cc_hash_table", comb_hash_fn_desc + resize_policy_desc + store_hash_desc));
+ return (make_xml_tag("type", "value", "cc_hash_table", comb_hash_fn_desc + resize_policy_desc + store_hash_desc));
}
};
template<typename Cntnr>
- struct ds_string_form<
- Cntnr,
- __gnu_pbds::gp_hash_tag>
+ struct ds_string_form<Cntnr, __gnu_pbds::gp_hash_tag>
{
static std::string
name()
const std::string store_hash_desc =
store_hash_string_form<Cntnr::store_hash>::desc();
-
- return (make_xml_tag( "type", "value", "gp_hash_table", comb_probe_fn_desc + probe_fn_desc + resize_policy_desc + store_hash_desc));
+
+ return make_xml_tag("type", "value", "gp_hash_table",
+ comb_probe_fn_desc + probe_fn_desc + resize_policy_desc + store_hash_desc);
}
};
{
if (tree_supports_order_statistics<Cntnr>::value)
return (container_category_str + "ost_");
-
- return (container_category_str);
+ return container_category_str;
}
static std::string
desc(const std::string container_category_str)
{
const std::string category_str =
- make_xml_tag( "Tag", "value", container_category_str);
+ make_xml_tag("Tag", "value", container_category_str);
const std::string node_update_str =
- make_xml_tag(
- "Node_Update",
- "value",(tree_supports_order_statistics<Cntnr>::value?
- "tree_order_statistics_node_update" : "null_tree_node_update"));
+ make_xml_tag("Node_Update",
+ "value",(tree_supports_order_statistics<Cntnr>::value ?
+ "tree_order_statistics_node_update" : "null_tree_node_update"));
- return (make_xml_tag( "type", "value", "tree", category_str + node_update_str));
+ return make_xml_tag("type", "value", "tree", category_str + node_update_str);
}
};
template<typename Cntnr>
- struct ds_string_form<
- Cntnr,
- __gnu_pbds::rb_tree_tag> : private tree_ds_string_form<
- Cntnr>
+ struct ds_string_form<Cntnr, __gnu_pbds::rb_tree_tag>
+ : private tree_ds_string_form<Cntnr>
{
private:
typedef tree_ds_string_form< Cntnr> base_type;
public:
static std::string
name()
- {
- return (base_type::name("rb_tree_"));
- }
+ { return base_type::name("rb_tree_"); }
static std::string
desc()
- {
- return (base_type::desc("rb_tree_tag"));
- }
+ { return base_type::desc("rb_tree_tag"); }
};
template<typename Cntnr>
- struct ds_string_form<
- Cntnr,
- __gnu_pbds::splay_tree_tag> : private tree_ds_string_form<
- Cntnr>
+ struct ds_string_form<Cntnr, __gnu_pbds::splay_tree_tag>
+ : private tree_ds_string_form<Cntnr>
{
private:
typedef tree_ds_string_form< Cntnr> base_type;
public:
static std::string
name()
- {
- return (base_type::name("splay_tree_"));
- }
+ { return base_type::name("splay_tree_"); }
static std::string
desc()
- {
- return (base_type::desc("splay_tree_tag"));
- }
+ { return base_type::desc("splay_tree_tag"); }
};
template<typename Cntnr>
- struct ds_string_form<
- Cntnr,
- __gnu_pbds::ov_tree_tag> : private tree_ds_string_form<
- Cntnr>
+ struct ds_string_form<Cntnr, __gnu_pbds::ov_tree_tag>
+ : private tree_ds_string_form<Cntnr>
{
private:
typedef tree_ds_string_form< Cntnr> base_type;
public:
static std::string
name()
- {
- return (base_type::name("ov_tree_"));
- }
+ { return (base_type::name("ov_tree_")); }
static std::string
desc()
- {
- return (base_type::desc("ov_tree_tag"));
- }
+ { return (base_type::desc("ov_tree_tag")); }
};
template<typename Cntnr>
- struct ds_string_form<
- Cntnr,
- __gnu_pbds::list_update_tag>
+ struct ds_string_form<Cntnr, __gnu_pbds::list_update_tag>
{
static std::string
name()
static std::string
desc()
{
- return (make_xml_tag(
- "type",
- "value",
- "list_update",
- lu_policy_string_form<typename Cntnr::update_policy>::desc()));
+ return make_xml_tag("type", "value", "list_update",
+ lu_policy_string_form<typename Cntnr::update_policy>::desc());
}
};
template<typename Cntnr>
- struct ds_string_form<
- Cntnr,
- __gnu_pbds::pat_trie_tag>
+ struct ds_string_form<Cntnr, __gnu_pbds::pat_trie_tag>
{
static std::string
name()
static std::string
desc()
{
- const std::string category_str =
- make_xml_tag( "Tag", "value", "pat_trie_tag");
-
- std::string node_update_desc;
-
+ std::string category_s = make_xml_tag("Tag", "value", "pat_trie_tag");
+ const char* s;
if (trie_supports_order_statistics<Cntnr>::value)
- node_update_desc =
- make_xml_tag( "Node_Update", "value", "trie_order_statistics_node_update");
+ s = "trie_order_statistics_node_update";
else if (trie_supports_prefix_search<Cntnr>::value)
- node_update_desc =
- make_xml_tag( "Node_Update", "value", "trie_prefix_search_node_update");
+ s = "trie_prefix_search_node_update";
else
- node_update_desc =
- make_xml_tag( "Node_Update", "value", "null_trie_node_update");
-
- return (make_xml_tag( "type", "value", "trie", category_str + node_update_desc));
+ s = "null_trie_node_update";
+ std::string node_s = make_xml_tag("Node_Update", "value", s);
+ return make_xml_tag("type", "value", "trie", category_s + node_s);
}
};
struct lu_policy_string_form;
template<>
- struct lu_policy_string_form<
- move_to_front_lu_policy_t_>
+ struct lu_policy_string_form<move_to_front_lu_policy_t_>
{
static std::string
name()
- {
- return ("mtf_");
- }
+ { return ("mtf_"); }
static std::string
desc()
{
- return (make_xml_tag( "Update_Policy", "value", "move_to_front_lu_policy"));
+ return make_xml_tag("Update_Policy", "value",
+ "move_to_front_lu_policy");
}
};
template<typename Allocator, typename Allocator::size_type Max_Count>
- struct lu_policy_string_form<
- counter_lu_policy_t_<
- Allocator,
- Max_Count> >
+ struct lu_policy_string_form<counter_lu_policy_t_<Allocator, Max_Count> >
{
static std::string
name()
{
std::ostringstream ret;
-
ret << "cnt_" << Max_Count << "_";
-
return (ret.str());
}
static std::string
desc()
{
- return (make_xml_tag( "Update_Policy", "value", "counter_lu_policy", "Max_Count", Max_Count));
+ return (make_xml_tag("Update_Policy", "value", "counter_lu_policy",
+ "Max_Count", Max_Count));
}
};
struct probe_fn_string_form;
template<typename Key, class Allocator>
- struct probe_fn_string_form<
- linear_probe_fn_t_<
- Key,
- Allocator> >
+ struct probe_fn_string_form<linear_probe_fn_t_<Key, Allocator> >
{
static std::string
name()
- {
- return ("linp_");
- }
+ { return ("linp_"); }
static std::string
desc()
- {
- return (make_xml_tag( "Probe_Fn", "value", "linear_probe_fn"));
- }
+ { return make_xml_tag("Probe_Fn", "value", "linear_probe_fn"); }
};
template<typename Key, class Allocator>
- struct probe_fn_string_form<
- quadratic_probe_fn_t_<
- Key,
- Allocator> >
+ struct probe_fn_string_form<quadratic_probe_fn_t_<Key, Allocator> >
{
static std::string
name()
- {
- return ("quadp_");
- }
+ { return ("quadp_"); }
static std::string
desc()
- {
- return (make_xml_tag( "Probe_Fn", "value", "quadratic_probe_fn"));
- }
+ { return make_xml_tag("Probe_Fn", "value", "quadratic_probe_fn"); }
};
template<>
- struct probe_fn_string_form<
- __gnu_pbds::null_probe_fn>
+ struct probe_fn_string_form<__gnu_pbds::null_probe_fn>
{
static std::string
name()
- {
- return ("");
- }
+ { return (""); }
static std::string
desc()
- {
- return (make_xml_tag( "Probe_Fn", "value", "null_probe_fn"));
- }
+ { return make_xml_tag("Probe_Fn", "value", "null_probe_fn"); }
};
} // namespace detail
typename Size_Type>
struct resize_policy_string_form<
__gnu_pbds::hash_standard_resize_policy<
- Size_Policy,
- Trigger_Policy,
- External_Size_Access,
- Size_Type> >
+ Size_Policy, Trigger_Policy, External_Size_Access, Size_Type> >
{
static std::string
name()
const std::string trigger_policy_string_form_desc =
trigger_policy_string_form<Trigger_Policy>::desc();
- return (make_xml_tag( "Resize_Policy", "value", "hash_standard_resize_policy", size_policy_string_form_desc + trigger_policy_string_form_desc));
+ return (make_xml_tag("Resize_Policy", "value", "hash_standard_resize_policy", size_policy_string_form_desc + trigger_policy_string_form_desc));
}
};
template<typename Allocator>
struct size_policy_string_form<
- __gnu_pbds::test::hash_exponential_size_policy_t_<
- Allocator> >
+ __gnu_pbds::test::hash_exponential_size_policy_t_<Allocator> >
{
static std::string
name()
- {
- return ("exp_");
- }
+ { return ("exp_"); }
static std::string
desc()
{
- return (make_xml_tag( "Size_Policy", "value", "hash_exponential_size_policy"));
+ return (make_xml_tag("Size_Policy", "value", "hash_exponential_size_policy"));
}
};
{
static std::string
name()
- {
- return ("prime_");
- }
+ { return ("prime_"); }
static std::string
desc()
{
- return (make_xml_tag( "Size_Policy", "value", "hash_prime_size_policy"));
+ return (make_xml_tag("Size_Policy", "value", "hash_prime_size_policy"));
}
};
{
static std::string
name()
- {
- return ("sth_");
- }
+ { return ("sth_"); }
static std::string
desc()
- {
- return (make_xml_tag( "Store_Hash", "value", "true"));
- }
+ { return (make_xml_tag("Store_Hash", "value", "true")); }
};
template<>
- struct store_hash_string_form<
- false>
+ struct store_hash_string_form<false>
{
static std::string
name()
- {
- return ("nsth_");
- }
+ { return ("nsth_"); }
static std::string
desc()
- {
- return (make_xml_tag( "Store_Hash", "value", "false"));
- }
+ { return (make_xml_tag("Store_Hash", "value", "false")); }
};
} // namespace detail
-
} // namespace test
-
} // namespace __gnu_pbds
#endif // #ifndef PB_DS_STORE_HASH_STRING_FORM_HPP
desc()
{
const std::string ext_access_desc =
- make_xml_tag(
- "External_Access",
+ make_xml_tag("External_Access",
"value",(External_Access? "true" : "false"));
const std::string loads_desc =
- make_xml_tag( "alpha_min", "nom", Min_Load_Nom, "denom", Min_Load_Denom) +
- make_xml_tag( "alpha_max", "nom", Max_Load_Nom, "denom", Max_Load_Denom);
+ make_xml_tag("alpha_min", "nom", Min_Load_Nom, "denom", Min_Load_Denom) +
+ make_xml_tag("alpha_max", "nom", Max_Load_Nom, "denom", Max_Load_Denom);
- return (make_xml_tag( "Trigger_Policy", "value", "hash_load_check_resize_trigger", ext_access_desc + loads_desc));
+ return (make_xml_tag("Trigger_Policy", "value", "hash_load_check_resize_trigger", ext_access_desc + loads_desc));
}
};
desc()
{
const std::string ext_access_desc =
- make_xml_tag(
- "External_Access",
+ make_xml_tag("External_Access",
"value",(External_Access? "true" : "false"));
const std::string load_desc =
- make_xml_tag( "alpha", "nom", Load_Nom, "denom", Load_Denom);
+ make_xml_tag("alpha", "nom", Load_Nom, "denom", Load_Denom);
- return (make_xml_tag( "Trigger_Policy", "value", "cc_hash_max_collision_check_resize_trigger", ext_access_desc + load_desc));
+ return (make_xml_tag("Trigger_Policy", "value", "cc_hash_max_collision_check_resize_trigger", ext_access_desc + load_desc));
}
};
#define PB_DS_NATIVE_SET_HPP
#include <ext/pb_ds/detail/standard_policies.hpp>
-#include <native_type/assoc/native_tree_tag.hpp>
+#include <native_type/native_tree_tag.hpp>
#include <io/xml.hpp>
#include <string>
#include <sstream>
#include <ext/pb_ds/detail/type_utils.hpp>
#include <ext/pb_ds/tag_and_trait.hpp>
-#include <native_type/assoc/native_hash_map.hpp>
-#include <native_type/assoc/native_hash_set.hpp>
-#include <native_type/assoc/native_multimap.hpp>
-#include <native_type/assoc/native_hash_multimap.hpp>
-#include <native_type/assoc/native_set.hpp>
+#include <native_type/native_hash_map.hpp>
+#include <native_type/native_hash_set.hpp>
+#include <native_type/native_multimap.hpp>
+#include <native_type/native_hash_multimap.hpp>
+#include <native_type/native_set.hpp>
#include <common_type/assoc/template_policy.hpp>
#include <common_type/assoc/detail/ds_string_form.hpp>
#include <regression/basic_type.hpp>
* Contains common types.
*/
-#ifndef PB_DS_COMMON_TYPES_HPP
-#define PB_DS_COMMON_TYPES_HPP
+#ifndef PB_DS_COMMON_TYPES_PQ_HPP
+#define PB_DS_COMMON_TYPES_PQ_HPP
#include <ext/pb_ds/detail/type_utils.hpp>
#include <ext/pb_ds/priority_queue.hpp>
struct pq_common_types
{
private:
- // typedef typename Allocator::size_type size_type;
-
typedef __gnu_pbds::priority_queue<Value_Type, Cmp_Fn, __gnu_pbds::pairing_heap_tag, Allocator> pairing_heap_t;
typedef __gnu_pbds::priority_queue<Value_Type, Cmp_Fn, __gnu_pbds::binomial_heap_tag, Allocator> binomial_heap_t;
} // namespace test
} // namespace __gnu_pbds
-#endif // #ifndef PB_DS_COMMON_TYPES_HPP
+#endif // #ifndef PB_DS_COMMON_TYPES_PQ_HPP
{ return make_xml_tag("type", "value", "binary_heap"); }
};
+ template<typename Cntnr>
+ struct ds_string_form<Cntnr, __gnu_pbds::sequence_tag>
+ {
+ static std::string
+ name()
+ { return "sequence"; }
+
+ static std::string
+ desc()
+ { return make_xml_tag("type", "value", "sequence"); }
+ };
+
} // namespace detail
} // namespace test
} // namespace __gnu_pbds
#include <string>
#include <sstream>
#include <ext/pb_ds/detail/type_utils.hpp>
-#include <native_type/priority_queue/native_priority_queue.hpp>
+#include <native_type/native_priority_queue.hpp>
#include <common_type/priority_queue/detail/ds_string_form.hpp>
#include <io/xml.hpp>
namespace __gnu_pbds
{
-
namespace test
{
-
prog_bar::
prog_bar(size_t max, std::ostream& r_os, bool display/*= true*/) :
m_cur(0),
if (m_display == false)
return;
- while (m_cur* num_disp >= m_max* m_cur_disp&& m_cur_disp < num_disp)
+ while (m_cur * num_disp >= m_max * m_cur_disp && m_cur_disp < num_disp)
{
m_r_os << '*';
m_r_os.flush();
-
++m_cur_disp;
}
}
#include <string>
#include <ext/pb_ds/detail/type_utils.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
-#include <native_type/assoc/native_hash_tag.hpp>
+#include <native_type/native_hash_tag.hpp>
#include <io/xml.hpp>
#include <tr1/unordered_map>
#include <tr1/unordered_map>
#include <ext/pb_ds/detail/type_utils.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
-#include <native_type/assoc/native_hash_tag.hpp>
+#include <native_type/native_hash_tag.hpp>
#include <io/xml.hpp>
namespace __gnu_pbds
public:
typedef native_hash_tag container_category;
- typedef Allocator allocator_type;
+ typedef Allocator allocator;
typedef typename base_type::iterator iterator;
typedef typename base_type::const_iterator const_iterator;
typedef
- typename allocator
_type::template rebind<pair_type>::other::const_reference
+ typename allocator::template rebind<pair_type>::other::const_reference
const_reference;
native_hash_multimap() : base_type(Init_Size)
#include <string>
#include <ext/pb_ds/detail/type_utils.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
-#include <native_type/assoc/native_hash_tag.hpp>
+#include <native_type/native_hash_tag.hpp>
#include <io/xml.hpp>
#include <tr1/unordered_set>
#include <string>
#include <ext/pb_ds/detail/type_utils.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
-#include <native_type/assoc/native_tree_tag.hpp>
+#include <native_type/native_tree_tag.hpp>
#include <io/xml.hpp>
namespace __gnu_pbds
#include <map>
#include <string>
#include <ext/pb_ds/detail/type_utils.hpp>
-#include <native_type/assoc/native_tree_tag.hpp>
+#include <native_type/native_tree_tag.hpp>
namespace __gnu_pbds
{
public:
typedef native_tree_tag container_category;
- typedef Allocator allocator_type;
+ typedef Allocator allocator;
typedef
typename Allocator::template rebind<
#include <string>
#include <ext/pb_ds/detail/type_utils.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
-#include <native_type/assoc/native_tree_tag.hpp>
+#include <native_type/native_tree_tag.hpp>
#include <io/xml.hpp>
namespace __gnu_pbds
/**
* @file basic_type.hpp
- * Containsert a type used for regression tests' key and data.
+ * Contains a type used for regression tests' key and data.
*/
#ifndef PB_DS_BASIC_TYPE_HPP
// -*- C++ -*-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2008 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the terms
#ifndef PB_DS_RAND_REGRESSION_TEST_COMMON_TYPE_HPP
#define PB_DS_RAND_REGRESSION_TEST_COMMON_TYPE_HPP
+#include <vector>
#include <regression/basic_type.hpp>
#include <common_type/assoc/common_type.hpp>
+#include <common_type/priority_queue/common_type.hpp>
namespace __gnu_pbds
{
typedef tl_t min_tl_t;
};
+
+ // Sequence types.
+ typedef pq_common_types<basic_type, std::less<basic_type>, alloc_type> pq_types;
+
+ typedef pq_types::regression_tl pq_tl_t;
+ typedef pq_tl_t min_pq_tl_t;
+
+ template<typename _Tp, typename _Alloc>
+ struct vector_adaptor : public std::vector<_Tp, _Alloc>
+ {
+ private:
+ typedef std::vector<_Tp, _Alloc> base_type;
+
+ public:
+ typedef typename base_type::value_type value_type;
+ typedef typename base_type::pointer pointer;
+ typedef typename base_type::const_pointer const_pointer;
+ typedef typename base_type::reference reference;
+ typedef typename base_type::const_reference const_reference;
+ typedef typename base_type::iterator iterator;
+ typedef typename base_type::const_iterator const_iterator;
+ typedef typename base_type::reverse_iterator reverse_iterator;
+ typedef typename base_type::const_reverse_iterator const_reverse_iterator;
+ typedef typename base_type::size_type size_type;
+ typedef typename base_type::difference_type difference_type;
+ typedef typename base_type::allocator_type allocator_type;
+
+ typedef __gnu_pbds::sequence_tag container_category;
+ typedef std::less<_Tp> cmp_fn;
+
+ const cmp_fn&
+ get_cmp_fn() const
+ { return _M_cmp; }
+
+ vector_adaptor() { }
+ vector_adaptor(iterator) { }
+ vector_adaptor(iterator, iterator) { }
+ vector_adaptor(iterator, iterator, const cmp_fn&) { }
+ vector_adaptor(const cmp_fn& other) { }
+
+ using base_type::push_back;
+ using base_type::pop_back;
+
+ // erase_if
+
+ cmp_fn _M_cmp;
+
+ };
+
+ namespace detail
+ {
+
+ };
+
+ typedef vector_adaptor<basic_type, alloc_type> vector_type;
+ typedef __gnu_cxx::typelist::create1<vector_type>::type vector_tl_t;
+ // Associative types.
typedef tree_types<null_mapped_type>::tl_t tree_set_tl_t;
typedef tree_types<null_mapped_type>::min_tl_t min_tree_set_tl_t;
typedef tree_types<basic_type>::tl_t tree_map_tl_t;
+++ /dev/null
-// -*- C++ -*-
-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License as published by the Free Software
-// Foundation; either version 2, or (at your option) any later
-// version.
-
-// This library is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this library; see the file COPYING. If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-
-// As a special exception, you may use this file as part of a free
-// software library without restriction. Specifically, if other files
-// instantiate templates or use macros or inline functions from this
-// file, or you compile this file and link it with other files to
-// produce an executable, this file does not by itself cause the
-// resulting executable to be covered by the GNU General Public
-// License. This exception does not however invalidate any other
-// reasons why the executable file might be covered by the GNU General
-// Public License.
-
-// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
-
-// Permission to use, copy, modify, sell, and distribute this software
-// is hereby granted without fee, provided that the above copyright
-// notice appears in all copies, and that both that copyright notice
-// and this permission notice appear in supporting documentation. None
-// of the above authors, nor IBM Haifa Research Laboratories, make any
-// representation about the suitability of this software for any
-// purpose. It is provided "as is" without express or implied
-// warranty.
-
-/**
- * @file common_type.hpp
- * Contains types used for regression tests.
- */
-
-#ifndef PB_DS_RAND_REGRESSION_TEST_COMMON_TYPE_HPP
-#define PB_DS_RAND_REGRESSION_TEST_COMMON_TYPE_HPP
-
-#include <regression/basic_type.hpp>
-#include <common_type/priority_queue/common_type.hpp>
-
-namespace __gnu_pbds
-{
-namespace test
-{
- typedef __gnu_cxx::throw_allocator<basic_type> alloc_type;
-
- typedef pq_common_types<basic_type, std::less<basic_type>, alloc_type>::regression_tl pq_tl_t;
-
- typedef pq_tl_t min_pq_tl_t;
-} // namespace test
-} // namespace __gnu_pbds
-
-#endif
// -*- C++ -*-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+// Copyright (C) 2005, 2006, 2008 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the terms
// warranty.
/**
- * @file container_rand_regression_test.hpp
+ * @file container_rand_regression_test.h
* Contains a random regression test for a specific container type.
*/
-#ifndef PB_DS_CONTAINER_RAND_REGRESSION_TEST_HPP
-#define PB_DS_CONTAINER_RAND_REGRESSION_TEST_HPP
+#ifndef PB_DS_CONTAINER_RAND_REGRESSION_TEST_H
+#define PB_DS_CONTAINER_RAND_REGRESSION_TEST_H
#include <algorithm>
#include <string>
#include <utility>
#include <ext/pb_ds/assoc_container.hpp>
#include <io/prog_bar.hpp>
-#include <rng/twister_rand_gen.hpp>
+#include <testsuite_rng.h>
#include <regression/trait/assoc/trait.hpp>
#include <common_type/assoc/string_form.hpp>
-#include <regression/rand/io/assoc/xml_formatter.hpp>
+#include <regression/rand/xml_formatter.hpp>
namespace __gnu_pbds
{
{
namespace detail
{
-
-#ifdef PB_DS_REGRESSION_TRACE
-#define PB_DS_TRACE(X) std::cerr << X << std::endl
-#else
-#define PB_DS_TRACE(X)
-#endif
-
-#define PB_DS_CLASS_T_DEC \
- template<typename Cntnr>
-
-#define PB_DS_CLASS_C_DEC \
- container_rand_regression_test<Cntnr>
-
-#define PB_DS_COND_COMPARE(L, R) \
- if (m_g.get_prob() < m_mp) \
- cmp(L, R, __FUNCTION__);
-
-#define PB_DS_RUN_MTHD(MTHD) \
- { \
- bool done = false; \
- \
- while (!done) \
- done = MTHD(); \
- }
-
-#define PB_DS_THROW_IF_FAILED_(PRED, MORE, P_C, P_NC, F, L) \
- if (!(PRED)) \
- { \
- std::cerr << "Failure at " << F << ": " << L << std::endl; \
- std::cerr << MORE << std::endl; \
- std::cerr << "container:" << std::endl; \
- print_container(*(P_C)); \
- std::cerr << std::endl; \
- std::cerr << "native container:" << std::endl; \
- print_container(*(P_NC)); \
- std::cerr << std::endl; \
- throw std::logic_error("fucked!"); \
- }
-
-#define PB_DS_THROW_IF_FAILED(PRED, MORE, P_C, P_NC) \
- PB_DS_THROW_IF_FAILED_(PRED, MORE, P_C, P_NC, __FILE__, __LINE__)
-
-#define PB_DS_SET_DESTRUCT_PRINT \
- destructor_printer dest_print___(__FUNCTION__);
-
-#define PB_DS_CANCEL_DESTRUCT_PRINT \
- dest_print___.cancel_print();
-
// Rand test specialized for a specific container.
template<typename Cntnr>
class container_rand_regression_test
private:
typedef Cntnr cntnr;
- typedef typename cntnr::allocator_type allocator_type;
+ typedef typename cntnr::allocator_type allocator_type;
typedef typename cntnr::size_type size_type;
typedef regression_test_traits<Cntnr> test_traits;
typedef typename test_traits::key_type key_type;
typedef typename test_traits::value_type value_type;
typedef typename test_traits::native_type native_type;
typedef twister_rand_gen gen;
- typedef __gnu_pbds::container_traits<Cntnr> container_traits;
+ typedef __gnu_pbds::container_traits<Cntnr> container_traits;
typedef __gnu_cxx::throw_allocator<char> alloc_t;
enum op
size_t m_i;
};
-#include <regression/rand/assoc/detail/constructor_destructor_fn_imps.hpp>
-#include <regression/rand/assoc/detail/cmp_fn_imps.hpp>
-#include <regression/rand/assoc/detail/operator_fn_imps.hpp>
-#include <regression/rand/assoc/detail/insert_fn_imps.hpp>
-#include <regression/rand/assoc/detail/subscript_fn_imps.hpp>
-#include <regression/rand/assoc/detail/clear_fn_imps.hpp>
-#include <regression/rand/assoc/detail/erase_fn_imps.hpp>
-#include <regression/rand/assoc/detail/defs_fn_imps.hpp>
-#include <regression/rand/assoc/detail/policy_access_fn_imps.hpp>
-#include <regression/rand/assoc/detail/split_join_fn_imps.hpp>
-#include <regression/rand/assoc/detail/it_conversion_fn_imps.hpp>
-#include <regression/rand/assoc/detail/resize_fn_imps.hpp>
-#include <regression/rand/assoc/detail/get_set_load_fn_imps.hpp>
-#include <regression/rand/assoc/detail/get_set_loads_fn_imps.hpp>
-#include <regression/rand/assoc/detail/diagnostic_fn_imps.hpp>
+#ifdef PB_DS_REGRESSION_TRACE
+#define PB_DS_TRACE(X) std::cerr << X << std::endl
+#else
+#define PB_DS_TRACE(X)
+#endif
+
+#define PB_DS_CLASS_T_DEC \
+ template<typename Cntnr>
+
+#define PB_DS_CLASS_C_DEC \
+ container_rand_regression_test<Cntnr>
+
+#define PB_DS_COND_COMPARE(L, R) \
+ if (m_g.get_prob() < m_mp) \
+ cmp(L, R, __FUNCTION__);
+
+#define PB_DS_RUN_MTHD(MTHD) \
+ { \
+ bool done = false; \
+ \
+ while (!done) \
+ done = MTHD(); \
+ }
+
+#define PB_DS_THROW_IF_FAILED_(PRED, MORE, P_C, P_NC, F, L) \
+ if (!(PRED)) \
+ { \
+ std::cerr << "Failure at " << F << ": " << L << std::endl; \
+ std::cerr << MORE << std::endl; \
+ std::cerr << "container:" << std::endl; \
+ print_container(*(P_C)); \
+ std::cerr << std::endl; \
+ std::cerr << "native container:" << std::endl; \
+ print_container(*(P_NC)); \
+ std::cerr << std::endl; \
+ throw std::logic_error("fucked!"); \
+ }
+
+#define PB_DS_THROW_IF_FAILED(PRED, MORE, P_C, P_NC) \
+ PB_DS_THROW_IF_FAILED_(PRED, MORE, P_C, P_NC, __FILE__, __LINE__)
+
+#define PB_DS_SET_DESTRUCT_PRINT \
+ destructor_printer dest_print___(__FUNCTION__);
+
+#define PB_DS_CANCEL_DESTRUCT_PRINT \
+ dest_print___.cancel_print();
+
+#include <regression/rand/assoc/container_rand_regression_test.tcc>
#undef PB_DS_COND_COMPARE
#undef PB_DS_RUN_MTHD
--- /dev/null
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 2, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING. If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free
+// software library without restriction. Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License. This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file container_rand_regression_test.tcc
+ * Contains a random regression test for a specific container type.
+ */
+
+#ifndef PB_DS_CONTAINER_RAND_REGRESSION_TEST_TCC
+#define PB_DS_CONTAINER_RAND_REGRESSION_TEST_TCC
+
+// Constructors/Destructors.
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+container_rand_regression_test(unsigned long seed, size_t n, size_t m,
+ double tp, double ip, double ep, double cp,
+ double mp, bool disp)
+: m_seed((seed == 0) ? twister_rand_gen::get_time_determined_seed() : seed),
+ m_n(n), m_m(m), m_tp(tp), m_ip(ip), m_ep(ep), m_cp(cp), m_mp(mp),
+ m_disp(disp), m_p_c(NULL)
+{ }
+
+PB_DS_CLASS_T_DEC
+PB_DS_CLASS_C_DEC::
+~container_rand_regression_test()
+{ }
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+default_constructor()
+{
+ PB_DS_TRACE("default_constructor");
+ bool done = true;
+ m_alloc.set_throw_prob(m_tp);
+
+ try
+ {
+ m_p_c = new Cntnr;
+ }
+ catch(__gnu_cxx::forced_exception_error&)
+ {
+ done = false;
+ }
+
+ if (m_p_c != NULL)
+ PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+ return done;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+swap()
+{
+ PB_DS_TRACE("swap");
+ m_alloc.set_throw_prob(0);
+ Cntnr* p_c = new Cntnr;
+ m_alloc.set_throw_prob(1);
+ p_c->swap(*m_p_c);
+ std::swap(p_c, m_p_c);
+ delete p_c;
+ PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+copy_constructor()
+{
+ PB_DS_TRACE("copy_constructor");
+ bool done = true;
+ Cntnr* p_c = NULL;
+ m_alloc.set_throw_prob(m_tp);
+ typename alloc_t::group_throw_prob_adjustor adjust(m_p_c->size());
+
+ try
+ {
+ p_c = new Cntnr(*m_p_c);
+ std::swap(p_c, m_p_c);
+ }
+ catch(__gnu_cxx::forced_exception_error& )
+ {
+ done = false;
+ }
+
+ delete p_c;
+ PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+ return done;
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+assignment_operator()
+{
+ PB_DS_TRACE("assignment operator");
+ bool done = true;
+ Cntnr* p_c = NULL;
+ m_alloc.set_throw_prob(m_tp);
+ typename alloc_t::group_throw_prob_adjustor adjust(m_p_c->size());
+
+ try
+ {
+ p_c = new Cntnr();
+ * p_c =* m_p_c;
+ std::swap(p_c, m_p_c);
+ }
+ catch(__gnu_cxx::forced_exception_error& )
+ {
+ done = false;
+ }
+
+ delete p_c;
+ PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+ return done;
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+it_constructor()
+{
+ PB_DS_TRACE("it_constructor");
+ return it_constructor_imp(typename Cntnr::container_category());
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+it_constructor_imp(__gnu_pbds::cc_hash_tag)
+{
+ bool done = true;
+ Cntnr* p_c = NULL;
+ m_alloc.set_throw_prob(m_tp);
+ typename alloc_t::group_throw_prob_adjustor adjust(m_p_c->size());
+
+ try
+ {
+ switch(get_next_sub_op(8))
+ {
+ case 0:
+ p_c = new Cntnr(m_p_c->get_hash_fn());
+ m_native_c.clear();
+ break;
+ case 1:
+ p_c = new Cntnr(m_p_c->get_hash_fn(), m_p_c->get_eq_fn());
+ m_native_c.clear();
+ break;
+ case 2:
+ p_c = new Cntnr(m_p_c->get_hash_fn(), m_p_c->get_eq_fn(),
+ m_p_c->get_comb_hash_fn());
+ m_native_c.clear();
+ break;
+ case 3:
+ p_c = new Cntnr(m_p_c->get_hash_fn(), m_p_c->get_eq_fn(),
+ m_p_c->get_comb_hash_fn(),
+ m_p_c->get_resize_policy());
+ m_native_c.clear();
+ break;
+ case 4:
+ p_c = new Cntnr(m_p_c->begin(), m_p_c->end());
+ break;
+ case 5:
+ p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_hash_fn());
+ break;
+ case 6:
+ p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_hash_fn(),
+ m_p_c->get_eq_fn());
+ break;
+ case 7:
+ p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_hash_fn(),
+ m_p_c->get_eq_fn(), m_p_c->get_comb_hash_fn());
+ break;
+ case 8:
+ p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_hash_fn(),
+ m_p_c->get_eq_fn(), m_p_c->get_comb_hash_fn(),
+ m_p_c->get_resize_policy());
+ break;
+ default:
+ PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
+ };
+ std::swap(p_c, m_p_c);
+ }
+ catch (__gnu_cxx::forced_exception_error&)
+ {
+ done = false;
+ }
+
+ delete p_c;
+ PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+ return done;
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+it_constructor_imp(__gnu_pbds::gp_hash_tag)
+{
+ bool done = true;
+ Cntnr* p_c = NULL;
+ m_alloc.set_throw_prob(m_tp);
+ typename alloc_t::group_throw_prob_adjustor adjust(m_p_c->size());
+
+ try
+ {
+ switch(get_next_sub_op(11))
+ {
+ case 0:
+ p_c = new Cntnr(m_p_c->get_hash_fn());
+ m_native_c.clear();
+ break;
+ case 1:
+ p_c = new Cntnr(m_p_c->get_hash_fn(), m_p_c->get_eq_fn());
+ m_native_c.clear();
+ break;
+ case 2:
+ p_c = new Cntnr(m_p_c->get_hash_fn(), m_p_c->get_eq_fn(),
+ m_p_c->get_comb_probe_fn());
+ m_native_c.clear();
+ break;
+ case 3:
+ p_c = new Cntnr(m_p_c->get_hash_fn(), m_p_c->get_eq_fn(),
+ m_p_c->get_comb_probe_fn());
+ m_native_c.clear();
+ break;
+ case 4:
+ p_c = new Cntnr(m_p_c->get_hash_fn(), m_p_c->get_eq_fn(),
+ m_p_c->get_comb_probe_fn(), m_p_c->get_probe_fn());
+ m_native_c.clear();
+ break;
+ case 5:
+ p_c = new Cntnr(m_p_c->get_hash_fn(), m_p_c->get_eq_fn(),
+ m_p_c->get_comb_probe_fn(), m_p_c->get_probe_fn(),
+ m_p_c->get_resize_policy());
+ m_native_c.clear();
+ break;
+ case 6:
+ p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_hash_fn());
+ break;
+ case 7:
+ p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_hash_fn(),
+ m_p_c->get_eq_fn());
+ break;
+ case 8:
+ p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_hash_fn(),
+ m_p_c->get_eq_fn(), m_p_c->get_comb_probe_fn());
+ break;
+ case 9:
+ p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_hash_fn(),
+ m_p_c->get_eq_fn(), m_p_c->get_comb_probe_fn());
+ break;
+ case 10:
+ p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_hash_fn(),
+ m_p_c->get_eq_fn(), m_p_c->get_comb_probe_fn(),
+ m_p_c->get_probe_fn());
+ break;
+ case 11:
+ p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_hash_fn(),
+ m_p_c->get_eq_fn(), m_p_c->get_comb_probe_fn(),
+ m_p_c->get_probe_fn(), m_p_c->get_resize_policy());
+ break;
+ default:
+ PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
+ };
+ std::swap(p_c, m_p_c);
+ }
+ catch (__gnu_cxx::forced_exception_error&)
+ {
+ done = false;
+ }
+
+ delete p_c;
+ PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+ return done;
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+it_constructor_imp(__gnu_pbds::tree_tag)
+{
+ bool done = true;
+ Cntnr* p_c = NULL;
+ m_alloc.set_throw_prob(m_tp);
+ typename alloc_t::group_throw_prob_adjustor adjust(m_p_c->size());
+
+ try
+ {
+ switch(get_next_sub_op(2))
+ {
+ case 0:
+ p_c = new Cntnr(m_p_c->get_cmp_fn());
+ m_native_c.clear();
+ break;
+ case 1:
+ p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_cmp_fn());
+ break;
+ default:
+ PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
+ };
+ std::swap(p_c, m_p_c);
+ }
+ catch (__gnu_cxx::forced_exception_error&)
+ {
+ done = false;
+ }
+
+ delete p_c;
+ PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+ return done;
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+it_constructor_imp(__gnu_pbds::list_update_tag)
+{
+ bool done = true;
+ Cntnr* p_c = NULL;
+ m_alloc.set_throw_prob(m_tp);
+ typename alloc_t::group_throw_prob_adjustor adjust(m_p_c->size());
+
+ try
+ {
+ p_c = new Cntnr(m_p_c->begin(), m_p_c->end());
+ std::swap(p_c, m_p_c);
+ }
+ catch (__gnu_cxx::forced_exception_error&)
+ {
+ done = false;
+ }
+
+ delete p_c;
+ PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+ return done;
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+it_constructor_imp(__gnu_pbds::pat_trie_tag)
+{
+ bool done = true;
+ Cntnr* p_c = NULL;
+ m_alloc.set_throw_prob(m_tp);
+ typename alloc_t::group_throw_prob_adjustor adjust(m_p_c->size());
+
+ try
+ {
+ switch(get_next_sub_op(2))
+ {
+ case 0:
+ p_c = new Cntnr(m_p_c->get_e_access_traits());
+ m_native_c.clear();
+ break;
+ case 1:
+ p_c = new Cntnr(m_p_c->begin(), m_p_c->end(),
+ m_p_c->get_e_access_traits());
+ break;
+ default:
+ PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
+ };
+
+ std::swap(p_c, m_p_c);
+ }
+ catch (__gnu_cxx::forced_exception_error&)
+ {
+ done = false;
+ }
+
+ delete p_c;
+ PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+ return done;
+}
+
+// Cmp.
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+cmp(const Cntnr& r_c, const native_type& r_native_c,
+ const std::string& r_call_fn)
+{
+ m_alloc.set_throw_prob(1);
+ const size_t size = r_c.size();
+ const size_t native_size = r_native_c.size();
+ PB_DS_THROW_IF_FAILED(size == native_size,
+ size << " " << native_size, &r_c, &r_native_c);
+
+ const bool empty = r_c.empty();
+ const bool native_empty = r_native_c.empty();
+ PB_DS_THROW_IF_FAILED(empty == native_empty,
+ empty << " " << native_empty, &r_c, &r_native_c);
+
+ try
+ {
+ basic_cmp_(r_c, r_native_c);
+ cmp_(r_c, r_native_c);
+ }
+ catch(...)
+ {
+ PB_DS_THROW_IF_FAILED(false, "call-fn: " + r_call_fn, &r_c, &r_native_c);
+ }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+basic_cmp_(const Cntnr& r_c, const native_type& r_native_c)
+{
+ PB_DS_SET_DESTRUCT_PRINT
+
+ if (static_cast<size_t>(std::distance(r_c.begin(), r_c.end())) != r_c.size())
+ PB_DS_THROW_IF_FAILED(false,
+ static_cast<unsigned long>(std::distance(r_c.begin(), r_c.end())) << " " << static_cast<unsigned long>(r_c.size()), &r_c, &r_native_c);
+
+ typename native_type::const_iterator it = r_native_c.begin();
+ while (it != r_native_c.end())
+ {
+ typename native_type::key_type native_key = test_traits::extract_native_key(*it);
+
+ m_alloc.set_throw_prob(0);
+ const key_type k = native_key;
+ m_alloc.set_throw_prob(1);
+ typename cntnr::const_point_iterator found_it = r_c.find(k);
+ PB_DS_THROW_IF_FAILED(found_it != r_c.end(),
+ test_traits::native_val_to_string(*it),
+ &r_c, &r_native_c);
+
+ if (!test_traits::cmp(*found_it, * it))
+ PB_DS_THROW_IF_FAILED(false, "", &r_c, &r_native_c);
+
+ ++it;
+ }
+ PB_DS_CANCEL_DESTRUCT_PRINT
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+cmp_(const Cntnr& r_c, const native_type& r_native_c)
+{
+ enum
+ {
+ order_preserving = container_traits::order_preserving,
+ back_order_preserving = container_traits::order_preserving
+ &&
+ !__gnu_pbds::detail::is_same<
+ typename std::iterator_traits<
+ typename cntnr::const_iterator>::iterator_category,
+ std::forward_iterator_tag>::value,
+ reverse_iteration = container_traits::reverse_iteration,
+ order_statistics = test_traits::order_statistics,
+ prefix_search = test_traits::prefix_search,
+ has_mapped = !__gnu_pbds::detail::is_same<
+ typename Cntnr::mapped_type,
+ __gnu_pbds::null_mapped_type>::value
+ };
+
+ order_preserving_cmp_imp(r_c, r_native_c,
+ __gnu_pbds::detail::integral_constant<int,order_preserving>());
+
+ back_order_preserving_cmp_imp(r_c, r_native_c,
+ __gnu_pbds::detail::integral_constant<int,back_order_preserving>());
+
+ order_statistics_cmp_imp(r_c, r_native_c,
+ __gnu_pbds::detail::integral_constant<int,order_statistics>());
+
+ prefix_search_cmp_imp(r_c, r_native_c,
+ __gnu_pbds::detail::integral_constant<int,prefix_search>());
+
+ reverse_iteration_cmp_imp(r_c, r_native_c,
+ __gnu_pbds::detail::integral_constant<int,reverse_iteration>());
+
+ lower_bound_cmp_imp(r_c, r_native_c,
+ __gnu_pbds::detail::integral_constant<int,order_preserving>());
+
+ upper_bound_cmp_imp(r_c, r_native_c,
+ __gnu_pbds::detail::integral_constant<int,order_preserving>());
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+order_preserving_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, __gnu_pbds::detail::false_type)
+{ }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+order_preserving_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, __gnu_pbds::detail::true_type)
+{
+ PB_DS_SET_DESTRUCT_PRINT
+
+ typename cntnr::const_iterator b = r_c.begin();
+ typename cntnr::const_iterator e = r_c.end();
+
+ typename native_type::const_iterator native_b = r_native_c.begin();
+ typename native_type::const_iterator native_e = r_native_c.end();
+
+ try
+ {
+ it_cmp_imp(b, e, native_b, native_e);
+ }
+ catch(...)
+ {
+ PB_DS_THROW_IF_FAILED(false, "", &r_c, &r_native_c)
+ }
+
+ try
+ {
+ back_it_cmp_imp(b, e, native_b, native_e);
+ }
+ catch(...)
+ {
+ PB_DS_THROW_IF_FAILED(false, "", &r_c, &r_native_c)
+ }
+
+ PB_DS_CANCEL_DESTRUCT_PRINT
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+back_order_preserving_cmp_imp(const Cntnr&, const native_type&,
+ __gnu_pbds::detail::false_type)
+{ }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+back_order_preserving_cmp_imp(const Cntnr& r_c, const native_type& r_native_c,
+ __gnu_pbds::detail::true_type)
+{
+ PB_DS_SET_DESTRUCT_PRINT
+ typename cntnr::const_iterator b = r_c.begin();
+ typename cntnr::const_iterator e = r_c.end();
+ typename native_type::const_iterator native_b = r_native_c.begin();
+ typename native_type::const_iterator native_e = r_native_c.end();
+ it_cmp_imp(b, e, native_b, native_e);
+ PB_DS_CANCEL_DESTRUCT_PRINT
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+reverse_iteration_cmp_imp(const Cntnr&, const native_type&,
+ __gnu_pbds::detail::false_type)
+{ }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+reverse_iteration_cmp_imp(const Cntnr& r_c, const native_type&r_native_c, __gnu_pbds::detail::true_type)
+{
+ PB_DS_SET_DESTRUCT_PRINT
+
+ typename cntnr::const_reverse_iterator b = r_c.rbegin();
+ typename cntnr::const_reverse_iterator e = r_c.rend();
+
+ typename native_type::const_reverse_iterator native_b = r_native_c.rbegin();
+ typename native_type::const_reverse_iterator native_e = r_native_c.rend();
+
+ try
+ {
+ it_cmp_imp(b, e, native_b, native_e);
+ }
+ catch(...)
+ {
+ PB_DS_THROW_IF_FAILED(false, "", &r_c, &r_native_c)
+ }
+
+ try
+ {
+ back_it_cmp_imp(b, e, native_b, native_e);
+ }
+ catch(...)
+ {
+ PB_DS_THROW_IF_FAILED(false, "", &r_c, &r_native_c)
+ }
+
+ PB_DS_CANCEL_DESTRUCT_PRINT
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+order_statistics_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, __gnu_pbds::detail::false_type)
+{ }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+order_statistics_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, __gnu_pbds::detail::true_type)
+{
+ {
+ m_alloc.set_throw_prob(0);
+ const key_type k = test_traits::generate_key(m_g, m_m);
+ m_alloc.set_throw_prob(1);
+ const size_type order = r_c.order_of_key(k);
+ const size_type native_order = std::distance(r_native_c.begin(),
+ r_native_c.lower_bound(test_traits::native_key(k)));
+
+ PB_DS_THROW_IF_FAILED(order == native_order,
+ test_traits::key_to_string(k) << " " <<
+ static_cast<unsigned long>(order) << " " <<
+ static_cast<unsigned long>(native_order),
+ &r_c,
+ &r_native_c);
+ }
+
+ const size_type rand_ord =
+ static_cast<size_t>(m_g.get_unsigned_long(0,
+ 2 * static_cast<unsigned long>(m_m)));
+
+ typename cntnr::const_iterator it = r_c.find_by_order(rand_ord);
+ typename native_type::const_iterator native_it = r_native_c.begin();
+ std::advance(native_it, std::min(rand_ord, r_native_c.size()));
+ if (it == r_c.end()&& native_it != r_native_c.end())
+ PB_DS_THROW_IF_FAILED(false,
+ static_cast<unsigned long>(rand_ord),
+ m_p_c,
+ &m_native_c);
+
+ if (it != r_c.end()&& native_it == r_native_c.end())
+ PB_DS_THROW_IF_FAILED(false,
+ static_cast<unsigned long>(rand_ord),
+ m_p_c,
+ &m_native_c);
+
+ if (it != r_c.end()&& native_it != r_native_c.end())
+ PB_DS_THROW_IF_FAILED(test_traits::cmp(*it, * native_it),
+ static_cast<unsigned long>(rand_ord),
+ m_p_c,
+ &m_native_c);
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+prefix_search_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, __gnu_pbds::detail::false_type)
+{ }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+prefix_search_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, __gnu_pbds::detail::true_type)
+{
+ PB_DS_SET_DESTRUCT_PRINT
+ m_alloc.set_throw_prob(0);
+ const key_type k = test_traits::generate_key(m_g, m_m);
+ m_alloc.set_throw_prob(1);
+ try
+ {
+ typedef
+ std::pair<typename Cntnr::const_iterator, typename Cntnr::const_iterator>
+ pref_ret_t;
+
+ const pref_ret_t pref_ret = r_c.prefix_range(k);
+
+ typename native_type::const_iterator native_start_it = r_native_c.begin();
+
+ while (native_start_it != r_native_c.end() &&
+ !test_traits::prefix_match(k,
+ test_traits::extract_native_key(*native_start_it)))
+ ++native_start_it;
+
+ typename native_type::const_iterator native_end_it =
+ native_start_it;
+
+ do
+ {
+ if (native_end_it != r_native_c.end())
+ ++native_end_it;
+ }
+ while (native_end_it != r_native_c.end() &&
+ test_traits::prefix_match(k,
+ test_traits::extract_native_key(*native_end_it)));
+
+ it_cmp_imp(pref_ret.first, pref_ret.second, native_start_it, native_end_it);
+ }
+ catch(...)
+ {
+ PB_DS_THROW_IF_FAILED(false, "prefix key " << k, &r_c, &r_native_c);
+ }
+
+ PB_DS_CANCEL_DESTRUCT_PRINT
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Const_It, class Const_Native_It>
+void
+PB_DS_CLASS_C_DEC::
+it_cmp_imp(Const_It b, Const_It e, Const_Native_It native_b,
+ Const_Native_It native_e)
+{
+ PB_DS_SET_DESTRUCT_PRINT
+
+ if (std::distance(b, e) != std::distance(native_b, native_e))
+ {
+ const size_t dist = std::distance(b, e);
+ const size_t native_dist = std::distance(native_b, native_e);
+ PB_DS_THROW_IF_FAILED(false,
+ static_cast<unsigned long>(dist) << " "
+ << static_cast<unsigned long>(native_dist),
+ m_p_c, &m_native_c);
+ }
+
+ while (b != e)
+ {
+ PB_DS_THROW_IF_FAILED(native_b != native_e, "", m_p_c, &m_native_c);
+
+ if (!test_traits::cmp(*b, * native_b))
+ PB_DS_THROW_IF_FAILED(false,
+ test_traits::val_to_string(*b) << " " <<
+ test_traits::val_to_string(*native_b),
+ m_p_c, &m_native_c);
+
+ ++b;
+ ++native_b;
+ }
+
+ PB_DS_THROW_IF_FAILED(native_b == native_e, "", m_p_c, &m_native_c);
+ PB_DS_CANCEL_DESTRUCT_PRINT
+}
+
+PB_DS_CLASS_T_DEC
+template<typename Const_It, class Const_Native_It>
+void
+PB_DS_CLASS_C_DEC::
+back_it_cmp_imp(Const_It b, Const_It e, Const_Native_It native_b,
+ Const_Native_It native_e)
+{
+ PB_DS_SET_DESTRUCT_PRINT
+ while (b != e)
+ {
+ PB_DS_THROW_IF_FAILED(native_b != native_e,
+ test_traits::val_to_string(*native_e),
+ m_p_c, &m_native_c);
+
+ --e;
+ --native_e;
+
+ PB_DS_THROW_IF_FAILED(test_traits::cmp(*e, * native_e),
+ test_traits::val_to_string(*e) <<
+ test_traits::val_to_string(*native_e),
+ m_p_c, &m_native_c);
+ }
+
+ PB_DS_THROW_IF_FAILED(native_b == native_e,
+ test_traits::val_to_string(*native_e),
+ m_p_c, &m_native_c);
+
+ PB_DS_CANCEL_DESTRUCT_PRINT
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+lower_bound_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, __gnu_pbds::detail::false_type)
+{ }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+lower_bound_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, __gnu_pbds::detail::true_type)
+{
+ PB_DS_SET_DESTRUCT_PRINT
+ m_alloc.set_throw_prob(0);
+ const key_type k = test_traits::generate_key(m_g, m_m);
+ m_alloc.set_throw_prob(1);
+ typename cntnr::const_iterator it = r_c.lower_bound(k);
+ typename native_type::key_type native_k = test_traits::native_key(k);
+ typename native_type::const_iterator native_it = r_native_c.lower_bound(native_k);
+
+ if (it != r_c.end() && native_it == r_native_c.end())
+ PB_DS_THROW_IF_FAILED("",
+ "it: " + test_traits::val_to_string(*it) + "\n\n",
+ &r_c, &r_native_c);
+
+ if (it == r_c.end() && native_it != r_native_c.end())
+ PB_DS_THROW_IF_FAILED("",
+ "native_it: " + test_traits::val_to_string(*native_it) + "\n\n",
+ &r_c, &r_native_c);
+
+ if (it != r_c.end() && !test_traits::cmp(*it, * native_it))
+ PB_DS_THROW_IF_FAILED(false,
+ "key: " + test_traits::key_to_string(k) + "\n\n" +
+ "it: " + test_traits::val_to_string(*it) + "\n\n" +
+ "native_it: " + test_traits::val_to_string(*native_it) + "\n\n",
+ &r_c, &r_native_c);
+
+ PB_DS_CANCEL_DESTRUCT_PRINT
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+upper_bound_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, __gnu_pbds::detail::false_type)
+{ }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+upper_bound_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, __gnu_pbds::detail::true_type)
+{
+ PB_DS_SET_DESTRUCT_PRINT
+ m_alloc.set_throw_prob(0);
+ const key_type k = test_traits::generate_key(m_g, m_m);
+ m_alloc.set_throw_prob(1);
+ typename cntnr::const_iterator it = r_c.upper_bound(k);
+ typename native_type::key_type native_k = test_traits::native_key(k);
+ typename native_type::const_iterator native_it = r_native_c.upper_bound(native_k);
+
+ if (it == r_c.end() && native_it != r_native_c.end())
+ PB_DS_THROW_IF_FAILED(false,
+ "key: " + test_traits::key_to_string(k) + "\n\n" +
+ "native_it: " + test_traits::val_to_string(*native_it) + "\n\n",
+ &r_c, &r_native_c);
+
+ if (it != r_c.end() && native_it == r_native_c.end())
+ PB_DS_THROW_IF_FAILED(false,
+ "key: " + test_traits::key_to_string(k) + "\n\n" +
+ "it: " + test_traits::val_to_string(*it) + "\n\n",
+ &r_c, &r_native_c);
+
+ if (it != r_c.end() && !test_traits::cmp(*it, * native_it))
+ PB_DS_THROW_IF_FAILED(false,
+ "key: " + test_traits::key_to_string(k) + "\n\n" +
+ "it: " + test_traits::val_to_string(*it) + "\n\n" +
+ "native_it: " + test_traits::val_to_string(*native_it) + "\n\n",
+ &r_c, &r_native_c);
+
+ PB_DS_CANCEL_DESTRUCT_PRINT
+}
+
+// Operators.
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+operator()()
+{
+ typedef xml_result_set_regression_formatter formatter_type;
+ formatter_type* p_fmt = NULL;
+
+ if (m_disp)
+ p_fmt = new formatter_type(string_form<Cntnr>::name(),
+ string_form<Cntnr>::desc());
+
+ m_g.init(m_seed);
+
+ // Track allocation from this point only.
+ const size_t memory_label = 775;
+ m_alloc.init(m_seed);
+ m_alloc.set_label(memory_label);
+
+ prog_bar pb(m_n, std::cout, m_disp);
+ m_i = 0;
+
+ try
+ {
+ for (m_i = 0; m_i < m_n; ++m_i)
+ {
+ PB_DS_TRACE("Op #" << static_cast<unsigned long>(m_i));
+ allocator_type::set_label(m_i);
+ switch (m_i)
+ {
+ case 0:
+ PB_DS_RUN_MTHD(default_constructor);
+ break;
+ case 1:
+ defs();
+ break;
+ case 2:
+ policy_access();
+ break;
+ case 3:
+ it_copy();
+ break;
+ case 4:
+ it_assign();
+ break;
+ case 5:
+ rev_it_copy();
+ break;
+ case 6:
+ rev_it_assign();
+ break;
+ default:
+ switch(get_next_op())
+ {
+ case insert_op:
+ switch(get_next_sub_op(2))
+ {
+ case 0:
+ PB_DS_RUN_MTHD(insert)
+ break;
+ case 1:
+ PB_DS_RUN_MTHD(subscript)
+ break;
+ default:
+ PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
+ }
+ break;
+ case erase_op:
+ switch(get_next_sub_op(4))
+ {
+ case 0:
+ PB_DS_RUN_MTHD(erase)
+ break;
+ case 1:
+ PB_DS_RUN_MTHD(erase_if)
+ break;
+ case 2:
+ PB_DS_RUN_MTHD(erase_it)
+ break;
+ case 3:
+ PB_DS_RUN_MTHD(erase_rev_it)
+ break;
+ default:
+ PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
+ }
+ break;
+ case clear_op:
+ PB_DS_RUN_MTHD(clear)
+ break;
+ case other_op:
+ switch(get_next_sub_op(8))
+ {
+ case 0:
+ swap();
+ break;
+ case 1:
+ PB_DS_RUN_MTHD(copy_constructor)
+ break;
+ case 2:
+ PB_DS_RUN_MTHD(it_constructor)
+ break;
+ case 3:
+ PB_DS_RUN_MTHD(assignment_operator)
+ break;
+ case 4:
+ PB_DS_RUN_MTHD(split_join)
+ break;
+ case 5:
+ resize();
+ break;
+ case 6:
+ get_set_load();
+ break;
+ case 7:
+ get_set_loads();
+ break;
+ default:
+ PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
+ }
+ break;
+ default:
+ PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
+ };
+ }
+
+ pb.inc();
+ }
+ }
+ catch (...)
+ {
+ std::cerr << "Failed at index " << static_cast<unsigned long>(m_i)
+ << std::endl;
+ delete m_p_c;
+ throw;
+ }
+
+ // Clean up, then check for allocation by special label, set above.
+ delete m_p_c;
+
+ try
+ { m_alloc.check_allocated(memory_label); }
+ catch (...)
+ {
+ std::cerr << "detected leaks!" << std::endl;
+ std::cerr << m_alloc << std::endl;
+ PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
+ }
+
+ // Reset throw probability.
+ m_alloc.set_throw_prob(0);
+
+ if (m_disp)
+ {
+ std::cout << std::endl;
+ delete p_fmt;
+ }
+}
+
+PB_DS_CLASS_T_DEC
+typename PB_DS_CLASS_C_DEC::op
+PB_DS_CLASS_C_DEC::
+get_next_op()
+{
+ const double prob = m_g.get_prob();
+ if (prob < m_ip)
+ return insert_op;
+
+ if (prob < m_ip + m_ep)
+ return erase_op;
+
+ if (prob < m_ip + m_ep + m_cp)
+ return clear_op;
+
+ PB_DS_THROW_IF_FAILED(prob <= 1, prob, m_p_c, &m_native_c);
+ return other_op;
+}
+
+PB_DS_CLASS_T_DEC
+size_t
+PB_DS_CLASS_C_DEC::
+get_next_sub_op(size_t max)
+{
+ const double p = m_g.get_prob();
+ const double delta = 1 / static_cast<double>(max);
+ size_t i = 0;
+ while (true)
+ if (p <= (i + 1) * delta)
+ {
+ PB_DS_THROW_IF_FAILED(i < max, i << " " << max, m_p_c, &m_native_c);
+ return i;
+ }
+ else
+ ++i;
+}
+
+// Insert.
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+insert()
+{
+ PB_DS_TRACE("insert");
+ bool done = true;
+ PB_DS_SET_DESTRUCT_PRINT
+ try
+ {
+ m_alloc.set_throw_prob(0);
+ value_type v = test_traits::generate_value(m_g, m_m);
+ m_alloc.set_throw_prob(m_tp);
+ const_key_reference r_k = test_traits::extract_key(v);
+ typename cntnr::const_point_iterator found_it = m_p_c->find(r_k);
+ const bool existed = (found_it != m_p_c->end());
+ const std::pair<typename cntnr::point_iterator, bool> ins_ret = m_p_c->insert(v);
+
+ if (ins_ret.second)
+ {
+ PB_DS_THROW_IF_FAILED(!existed, "", m_p_c, &m_native_c);
+ }
+ else
+ {
+ PB_DS_THROW_IF_FAILED(existed, "", m_p_c, &m_native_c);
+ PB_DS_THROW_IF_FAILED(found_it == ins_ret.first, "", m_p_c, &m_native_c);
+ }
+ m_native_c.insert(test_traits::native_value(v));
+ }
+ catch(__gnu_cxx::forced_exception_error&)
+ {
+ done = false;
+ }
+ catch(__gnu_pbds::insert_error&)
+ {
+ PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
+ }
+
+ PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+ PB_DS_CANCEL_DESTRUCT_PRINT
+ return done;
+}
+
+// Subscript.
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+subscript()
+{
+ PB_DS_TRACE("subscript");
+
+ enum
+ {
+ no_data = __gnu_pbds::detail::is_same<
+ typename Cntnr::const_key_reference,
+ typename Cntnr::const_reference>::value
+ };
+
+ return (subscript_imp(__gnu_pbds::detail::integral_constant<int,no_data>()));
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+subscript_imp(__gnu_pbds::detail::false_type)
+{
+ bool done = true;
+ PB_DS_SET_DESTRUCT_PRINT
+
+ try
+ {
+ m_alloc.set_throw_prob(0);
+ value_type v = test_traits::generate_value(m_g, m_m);
+
+ m_alloc.set_throw_prob(m_tp);
+ (*m_p_c)[v.first] = v.second;
+
+ m_native_c[test_traits::native_value(v).first] =
+ test_traits::native_value(v).second;
+ }
+ catch(__gnu_cxx::forced_exception_error& )
+ {
+ done = false;
+ }
+
+ PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+ PB_DS_CANCEL_DESTRUCT_PRINT
+ return done;
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+subscript_imp(__gnu_pbds::detail::true_type)
+{
+ bool done = true;
+ PB_DS_SET_DESTRUCT_PRINT
+ try
+ {
+ m_alloc.set_throw_prob(0);
+ value_type v = test_traits::generate_value(m_g, m_m);
+ m_alloc.set_throw_prob(m_tp);
+ (*m_p_c)[v] = __gnu_pbds::null_mapped_type();
+ m_native_c.insert(test_traits::native_value(v));
+ }
+ catch(__gnu_cxx::forced_exception_error& )
+ {
+ done = false;
+ }
+
+ PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+ PB_DS_CANCEL_DESTRUCT_PRINT
+ return done;
+}
+
+// Clear.
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+clear()
+{
+ m_p_c->clear();
+ m_native_c.clear();
+ return true;
+}
+
+
+// Erase.
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+erase()
+{
+ PB_DS_TRACE("erase");
+ bool done = true;
+ PB_DS_SET_DESTRUCT_PRINT
+ m_alloc.set_throw_prob(0);
+ const key_type k = test_traits::generate_key(m_g, m_m);
+ m_alloc.set_throw_prob(m_tp);
+
+ try
+ {
+ const bool cntnd = m_p_c->find(k) != m_p_c->end();
+ PB_DS_THROW_IF_FAILED(cntnd ==(m_native_c.find(test_traits::native_key(k)) != m_native_c.end()), test_traits::key_to_string(k), m_p_c, &m_native_c);
+
+ const bool ersd = m_p_c->erase(k);
+ const bool native_ersd = m_native_c.erase(test_traits::native_key(k)) != 0;
+
+ PB_DS_THROW_IF_FAILED(ersd == native_ersd, ersd << " " << native_ersd,
+ m_p_c, &m_native_c);
+
+ PB_DS_THROW_IF_FAILED(m_p_c->find(k) == m_p_c->end(), "",
+ m_p_c, &m_native_c);
+ }
+ catch(__gnu_cxx::forced_exception_error& )
+ {
+ done = false;
+
+ PB_DS_THROW_IF_FAILED( container_traits::erase_can_throw, container_traits::erase_can_throw, m_p_c, &m_native_c);
+ }
+
+ PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+ PB_DS_CANCEL_DESTRUCT_PRINT
+ return done;
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+erase_if()
+{
+ PB_DS_TRACE("erase_if");
+ bool done = true;
+ PB_DS_SET_DESTRUCT_PRINT
+
+ try
+ {
+ typedef
+ typename std::iterator_traits<typename cntnr::iterator>::reference
+ it_const_reference;
+
+ typedef
+ typename test_traits::template erase_if_fn<value_type>
+ erase_if_fn_t;
+
+ m_alloc.set_throw_prob(m_tp);
+
+ const size_t ersd = m_p_c->erase_if(erase_if_fn_t());
+ const size_t native_ersd = test_traits::erase_if(m_native_c);
+ PB_DS_THROW_IF_FAILED(ersd == native_ersd,
+ ersd << " " << native_ersd, m_p_c, &m_native_c);
+ }
+ catch(__gnu_cxx::forced_exception_error&)
+ {
+ done = false;
+ PB_DS_THROW_IF_FAILED(container_traits::erase_can_throw,
+ container_traits::erase_can_throw,
+ m_p_c, &m_native_c);
+ }
+
+ PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+ PB_DS_CANCEL_DESTRUCT_PRINT
+ return done;
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+erase_it()
+{
+ enum
+ {
+ erase_iterators = container_traits::order_preserving
+ };
+
+ return (erase_it_imp(__gnu_pbds::detail::integral_constant<int,erase_iterators>()));
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+erase_it_imp(__gnu_pbds::detail::false_type)
+{
+ return true;
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+erase_it_imp(__gnu_pbds::detail::true_type)
+{
+ PB_DS_TRACE("erase_it");
+ bool done = true;
+ PB_DS_SET_DESTRUCT_PRINT
+
+ try
+ {
+ m_alloc.set_throw_prob(0);
+ const key_type k = test_traits::generate_key(m_g, m_m);
+ m_alloc.set_throw_prob(m_tp);
+
+ typename cntnr::iterator found_it = m_p_c->find(k);
+
+ typename native_type::iterator native_it = m_native_c.find(test_traits::native_key(k));
+
+ const bool found = found_it != m_p_c->end();
+ const bool native_found = native_it != m_native_c.end();
+
+ PB_DS_THROW_IF_FAILED(
+ found == native_found,
+ found << " " << native_found,
+ m_p_c,
+ &m_native_c);
+
+ typename cntnr::const_iterator next_it = found_it;
+ if (next_it != m_p_c->end())
+ ++next_it;
+
+ typename cntnr::iterator next_ers_it = m_p_c->erase(found_it);
+
+ if (native_it != m_native_c.end())
+ m_native_c.erase(native_it);
+
+ bool range_guarantee = __gnu_pbds::detail::is_same<
+ typename container_traits::invalidation_guarantee,
+ __gnu_pbds::range_invalidation_guarantee>::value ;
+
+ if (range_guarantee)
+ PB_DS_THROW_IF_FAILED(next_ers_it == next_it, "", m_p_c, &m_native_c);
+ }
+ catch(__gnu_cxx::forced_exception_error& )
+ {
+ done = false;
+ PB_DS_THROW_IF_FAILED(container_traits::erase_can_throw, container_traits::erase_can_throw, m_p_c, &m_native_c);
+ }
+
+ PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+ PB_DS_CANCEL_DESTRUCT_PRINT
+ return done;
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+erase_rev_it()
+{
+ enum
+ {
+ erase_iterators = container_traits::order_preserving
+ && container_traits::reverse_iteration
+ };
+
+ return (erase_rev_it_imp(__gnu_pbds::detail::integral_constant<int,erase_iterators>()));
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+erase_rev_it_imp(__gnu_pbds::detail::false_type)
+{
+ return true;
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+erase_rev_it_imp(__gnu_pbds::detail::true_type)
+{
+ PB_DS_TRACE("erase_rev_it");
+ bool done = true;
+ PB_DS_SET_DESTRUCT_PRINT
+
+ try
+ {
+ m_alloc.set_throw_prob(0);
+ const key_type k = test_traits::generate_key(m_g, m_m);
+ m_alloc.set_throw_prob(m_tp);
+
+ typename cntnr::iterator found_it = m_p_c->find(k);
+ typename native_type::iterator native_it = m_native_c.find(test_traits::native_key(k));
+
+ typename cntnr::const_reverse_iterator next_it = found_it;
+ if (next_it != m_p_c->end())
+ ++next_it;
+
+ typename cntnr::reverse_iterator next_ers_it =
+ m_p_c->erase((typename cntnr::reverse_iterator)found_it);
+
+ PB_DS_THROW_IF_FAILED(next_ers_it == next_it, "", m_p_c, &m_native_c);
+
+ if (native_it != m_native_c.end())
+ m_native_c.erase(native_it);
+ }
+ catch(__gnu_cxx::forced_exception_error& )
+ {
+ done = false;
+ PB_DS_THROW_IF_FAILED(container_traits::erase_can_throw,
+ container_traits::erase_can_throw,
+ m_p_c, &m_native_c);
+ }
+
+ PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+ PB_DS_CANCEL_DESTRUCT_PRINT
+ return done;
+}
+
+// Defs.
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+defs()
+{
+ // General container types.
+ typedef typename Cntnr::size_type test_size_type;
+ typedef typename Cntnr::difference_type difference_type;
+
+ key_defs();
+ mapped_defs();
+ value_defs();
+ iterator_defs();
+ node_iterator_defs(__gnu_pbds::detail::integral_constant<int,
+ container_traits::order_preserving>());
+ policy_defs();
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+key_defs()
+{
+ typedef typename Cntnr::key_type test_key_type;
+ typedef typename Cntnr::key_reference test_key_reference;
+ typedef typename Cntnr::const_key_reference test_const_key_reference;
+ typedef typename Cntnr::key_pointer test_key_pointer;
+ typedef typename Cntnr::const_key_pointer test_const_key_pointer;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+mapped_defs()
+{
+ typedef typename Cntnr::mapped_type test_mapped_type;
+ typedef typename Cntnr::mapped_reference test_mapped_reference;
+ typedef typename Cntnr::const_mapped_reference test_const_mapped_reference;
+ typedef typename Cntnr::mapped_pointer test_mapped_pointer;
+ typedef typename Cntnr::const_mapped_pointer test_const_mapped_pointer;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+value_defs()
+{
+ typedef typename Cntnr::value_type test_value_type;
+ typedef typename Cntnr::reference test_reference;
+ typedef typename Cntnr::const_reference test_const_reference;
+ typedef typename Cntnr::pointer test_pointer;
+ typedef typename Cntnr::const_pointer test_const_pointer;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+ds_defs()
+{
+ typedef __gnu_pbds::container_traits< Cntnr> test_container_traits;
+
+ typedef typename test_container_traits::container_category test_container_category;
+
+ typedef
+ typename test_container_traits::invalidation_guarantee
+ test_invalidation_guarantee;
+
+ enum
+ {
+ test_order_preserving = test_container_traits::order_preserving
+ };
+
+ enum
+ {
+ test_erase_can_throw = test_container_traits::erase_can_throw
+ };
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+iterator_defs()
+{
+ typedef typename Cntnr::point_iterator test_point_iterator;
+ typedef typename Cntnr::const_point_iterator const_test_point_iterator;
+ typedef typename Cntnr::iterator test_iterator;
+ typedef typename Cntnr::const_iterator const_test_iterator;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+node_iterator_defs(__gnu_pbds::detail::false_type)
+{ }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+node_iterator_defs(__gnu_pbds::detail::true_type)
+{
+ typedef typename Cntnr::node_iterator test_node_iterator;
+ typedef typename Cntnr::const_node_iterator test_const_node_iterator;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+policy_defs()
+{
+ typedef typename Cntnr::allocator_type test_allocator;
+ policy_defs(typename Cntnr::container_category());
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+policy_defs(__gnu_pbds::basic_hash_tag)
+{
+ typedef typename Cntnr::hash_fn test_hash_fn;
+ typedef typename Cntnr::eq_fn test_eq_fn;
+ typedef typename Cntnr::resize_policy test_resize_policy;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+policy_defs(__gnu_pbds::cc_hash_tag)
+{
+ policy_defs(__gnu_pbds::basic_hash_tag());
+ typedef typename Cntnr::comb_hash_fn test_comb_hash_fn;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+policy_defs(__gnu_pbds::gp_hash_tag)
+{
+ policy_defs(__gnu_pbds::basic_hash_tag());
+ typedef typename Cntnr::comb_probe_fn test_comb_probe_fn;
+ typedef typename Cntnr::probe_fn test_probe_fn;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+policy_defs(__gnu_pbds::tree_tag)
+{
+ typedef typename Cntnr::cmp_fn test_cmp_fn;
+ typedef typename Cntnr::node_update test_node_update;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+policy_defs(__gnu_pbds::list_update_tag)
+{
+ typedef typename Cntnr::eq_fn test_eq_fn;
+ typedef typename Cntnr::update_policy test_update_policy;
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+policy_defs(__gnu_pbds::pat_trie_tag)
+{
+ typedef typename Cntnr::e_access_traits e_access_traits;
+}
+
+
+// Policy Access.
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+policy_access()
+{
+ policy_access(typename Cntnr::container_category());
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+policy_access(__gnu_pbds::basic_hash_tag)
+{
+ {
+ typename Cntnr::hash_fn& r_t = m_p_c->get_hash_fn();
+ assert(&r_t != NULL);
+ }
+ {
+ const typename Cntnr::hash_fn& r_t =((const Cntnr& )*m_p_c).get_hash_fn();
+ assert(&r_t != NULL);
+ }
+
+ {
+ typename Cntnr::eq_fn& r_t = m_p_c->get_eq_fn();
+ assert(&r_t != NULL);
+ }
+ {
+ const typename Cntnr::eq_fn& r_t =((const Cntnr& )*m_p_c).get_eq_fn();
+ assert(&r_t != NULL);
+ }
+
+ {
+ typename Cntnr::resize_policy& r_t = m_p_c->get_resize_policy();
+ assert(&r_t != NULL);
+ }
+ {
+ const typename Cntnr::resize_policy& r_t =((const Cntnr& )*m_p_c).get_resize_policy();
+
+ assert(&r_t != NULL);
+ }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+policy_access(__gnu_pbds::cc_hash_tag)
+{
+ policy_access(__gnu_pbds::basic_hash_tag());
+
+ {
+ typename Cntnr::comb_hash_fn& r_t = m_p_c->get_comb_hash_fn();
+ assert(&r_t != NULL);
+ }
+ {
+ const typename Cntnr::comb_hash_fn& r_t =((const Cntnr& )*m_p_c).get_comb_hash_fn();
+
+ assert(&r_t != NULL);
+ }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+policy_access(__gnu_pbds::gp_hash_tag)
+{
+ policy_access(__gnu_pbds::basic_hash_tag());
+
+ {
+ typename Cntnr::comb_probe_fn& r_t = m_p_c->get_comb_probe_fn();
+ assert(&r_t != NULL);
+ }
+ {
+ const typename Cntnr::comb_probe_fn& r_t =((const Cntnr& )*m_p_c).get_comb_probe_fn();
+
+ assert(&r_t != NULL);
+ }
+
+ {
+ typename Cntnr::probe_fn& r_t = m_p_c->get_probe_fn();
+ assert(&r_t != NULL);
+ }
+ {
+ const typename Cntnr::probe_fn& r_t =((const Cntnr& )*m_p_c).get_probe_fn();
+ assert(&r_t != NULL);
+ }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+policy_access(__gnu_pbds::tree_tag)
+{
+ {
+ typename Cntnr::cmp_fn& r_t = m_p_c->get_cmp_fn();
+ assert(&r_t != NULL);
+ }
+
+ {
+ const typename Cntnr::cmp_fn& r_t =((const Cntnr& )*m_p_c).get_cmp_fn();
+ assert(&r_t != NULL);
+ }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+policy_access(__gnu_pbds::list_update_tag)
+{ }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+policy_access(__gnu_pbds::pat_trie_tag)
+{
+ typename Cntnr::e_access_traits& r_t = m_p_c->get_e_access_traits();
+ assert(&r_t != NULL);
+}
+
+
+// Split/Join.
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+split_join()
+{
+ enum
+ {
+ split_join = container_traits::order_preserving
+ };
+
+ return (split_join_imp(__gnu_pbds::detail::integral_constant<int,split_join>()));
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+split_join_imp(__gnu_pbds::detail::false_type)
+{
+ return true;
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+split_join_imp(__gnu_pbds::detail::true_type)
+{
+ PB_DS_TRACE("split_join");
+ bool done = true;
+ PB_DS_SET_DESTRUCT_PRINT
+
+ try
+ {
+ m_alloc.set_throw_prob(0);
+ Cntnr lhs(*m_p_c);
+ Cntnr rhs;
+ native_type native_lhs(m_native_c);
+ native_type native_rhs;
+ const key_type k = test_traits::generate_key(m_g, m_m);
+
+ m_alloc.set_throw_prob(m_tp);
+ lhs.split(k, rhs);
+
+ typename native_type::const_iterator it =
+ native_lhs.upper_bound(test_traits::native_key(k));
+
+ while (!native_lhs.empty()&& it != native_lhs.end())
+ {
+ native_rhs.insert(*it);
+ typename native_type::const_iterator next_it = it;
+ ++next_it;
+ native_lhs.erase(test_traits::extract_native_key(*it));
+ it = next_it;
+ }
+
+ PB_DS_COND_COMPARE(lhs, native_lhs);
+ PB_DS_COND_COMPARE(rhs, native_rhs);
+
+ m_alloc.set_throw_prob(m_tp);
+
+ if (m_g.get_prob() < 0.5)
+ lhs.swap(rhs);
+
+ lhs.join(rhs);
+ PB_DS_THROW_IF_FAILED(rhs.size() == 0, rhs.size(), m_p_c, &m_native_c);
+ PB_DS_THROW_IF_FAILED(rhs.empty(), rhs.size(), m_p_c, &m_native_c);
+ m_p_c->swap(lhs);
+ }
+ catch(__gnu_cxx::forced_exception_error& )
+ {
+ done = false;
+ PB_DS_THROW_IF_FAILED(container_traits::split_join_can_throw,
+ container_traits::split_join_can_throw,
+ m_p_c, &m_native_c);
+ }
+
+ PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+ PB_DS_CANCEL_DESTRUCT_PRINT
+ return done;
+}
+
+// Iterator conversions.
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+it_copy()
+{
+ {
+ typename cntnr::iterator it = m_p_c->end();
+ typename cntnr::const_iterator const_it(it);
+ PB_DS_THROW_IF_FAILED(const_it == it, "", m_p_c, &m_native_c);
+ PB_DS_THROW_IF_FAILED(!(const_it != it), "", m_p_c, &m_native_c);
+
+ typename cntnr::const_point_iterator const_find_it(it);
+ PB_DS_THROW_IF_FAILED(const_find_it == it, "", m_p_c, &m_native_c);
+ PB_DS_THROW_IF_FAILED(!(const_find_it != it), "", m_p_c, &m_native_c);
+
+ typename cntnr::point_iterator find_it(it);
+ PB_DS_THROW_IF_FAILED(find_it == it, "", m_p_c, &m_native_c);
+ PB_DS_THROW_IF_FAILED(!(find_it != it), "", m_p_c, &m_native_c);
+ }
+
+ {
+ typename cntnr::const_iterator const_it = m_p_c->end();
+ typename cntnr::const_point_iterator const_find_it(const_it);
+ PB_DS_THROW_IF_FAILED(const_find_it == const_it, "", m_p_c, &m_native_c);
+ PB_DS_THROW_IF_FAILED(!(const_find_it != const_it), "", m_p_c, &m_native_c);
+ }
+
+ {
+ typename cntnr::point_iterator find_it = m_p_c->end();
+ typename cntnr::const_point_iterator const_find_it(find_it);
+ PB_DS_THROW_IF_FAILED(find_it == const_find_it, "", m_p_c, &m_native_c);
+ PB_DS_THROW_IF_FAILED(!(find_it != const_find_it), "", m_p_c, &m_native_c);
+ }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+it_assign()
+{
+ {
+ typename cntnr::iterator it = m_p_c->end();
+ typename cntnr::const_iterator const_it;
+ const_it = it;
+ PB_DS_THROW_IF_FAILED(const_it == it, "", m_p_c, &m_native_c);
+ PB_DS_THROW_IF_FAILED(!(const_it != it), "", m_p_c, &m_native_c);
+
+ typename cntnr::const_point_iterator const_find_it;
+ const_find_it = it;
+ PB_DS_THROW_IF_FAILED(const_find_it == it, "", m_p_c, &m_native_c);
+ PB_DS_THROW_IF_FAILED(!(const_find_it != it), "", m_p_c, &m_native_c);
+
+ typename cntnr::point_iterator find_it;
+ find_it = it;
+ PB_DS_THROW_IF_FAILED(find_it == it, "", m_p_c, &m_native_c);
+ PB_DS_THROW_IF_FAILED(!(find_it != it), "", m_p_c, &m_native_c);
+ }
+
+ {
+ typename cntnr::const_iterator const_it = m_p_c->end();
+ typename cntnr::const_point_iterator const_find_it;
+ const_find_it = const_it;
+ PB_DS_THROW_IF_FAILED(const_find_it == const_it, "", m_p_c, &m_native_c);
+ PB_DS_THROW_IF_FAILED(!(const_find_it != const_it), "", m_p_c, &m_native_c);
+ }
+
+ {
+ typename cntnr::point_iterator find_it = m_p_c->end();
+ typename cntnr::const_point_iterator const_find_it;
+ const_find_it = find_it;
+ PB_DS_THROW_IF_FAILED(find_it == const_find_it, "", m_p_c, &m_native_c);
+ PB_DS_THROW_IF_FAILED(!(find_it != const_find_it), "", m_p_c, &m_native_c);
+ }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+rev_it_copy()
+{
+ enum
+ {
+ reverse_iteration = container_traits::reverse_iteration
+ };
+
+ rev_it_copy_imp(__gnu_pbds::detail::integral_constant<int,reverse_iteration>());
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+rev_it_assign()
+{
+ enum
+ {
+ reverse_iteration = container_traits::reverse_iteration
+ };
+
+ rev_it_assign_imp(__gnu_pbds::detail::integral_constant<int,reverse_iteration>());
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+rev_it_copy_imp(__gnu_pbds::detail::false_type)
+{ }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+rev_it_copy_imp(__gnu_pbds::detail::true_type)
+{
+ {
+ typename cntnr::iterator it = m_p_c->end();
+ typename cntnr::const_reverse_iterator const_it(it);
+ PB_DS_THROW_IF_FAILED(const_it == it, "", m_p_c, &m_native_c);
+ PB_DS_THROW_IF_FAILED(!(const_it != it), "", m_p_c, &m_native_c);
+
+ typename cntnr::const_point_iterator const_find_it(it);
+ PB_DS_THROW_IF_FAILED(const_find_it == it, "", m_p_c, &m_native_c);
+ PB_DS_THROW_IF_FAILED(!(const_find_it != it), "", m_p_c, &m_native_c);
+
+ typename cntnr::point_iterator find_it(it);
+ PB_DS_THROW_IF_FAILED(find_it == it, "", m_p_c, &m_native_c);
+ PB_DS_THROW_IF_FAILED(!(find_it != it), "", m_p_c, &m_native_c);
+ }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+rev_it_assign_imp(__gnu_pbds::detail::false_type)
+{ }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+rev_it_assign_imp(__gnu_pbds::detail::true_type)
+{
+ {
+ typename cntnr::iterator it = m_p_c->end();
+ typename cntnr::const_reverse_iterator const_it;
+ const_it = it;
+ PB_DS_THROW_IF_FAILED(const_it == it, "", m_p_c, &m_native_c);
+ PB_DS_THROW_IF_FAILED(!(const_it != it), "", m_p_c, &m_native_c);
+
+ typename cntnr::const_point_iterator const_find_it;
+ const_find_it = it;
+ PB_DS_THROW_IF_FAILED(const_find_it == it, "", m_p_c, &m_native_c);
+ PB_DS_THROW_IF_FAILED(!(const_find_it != it), "", m_p_c, &m_native_c);
+
+ typename cntnr::point_iterator find_it;
+ find_it = it;
+ PB_DS_THROW_IF_FAILED(find_it == it, "", m_p_c, &m_native_c);
+ PB_DS_THROW_IF_FAILED(!(find_it != it), "", m_p_c, &m_native_c);
+ }
+}
+
+// Resize.
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+resize()
+{
+ typedef __gnu_pbds::detail::integral_constant<int, test_traits::resize> resize_ind;
+
+ return resize_imp(resize_ind());
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+resize_imp(__gnu_pbds::detail::false_type)
+{
+ return true;
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+resize_imp(__gnu_pbds::detail::true_type)
+{
+ PB_DS_TRACE("resize");
+ bool done = true;
+ PB_DS_SET_DESTRUCT_PRINT
+ const size_t old_size = m_p_c->get_actual_size();
+
+ try
+ {
+ enum
+ {
+ min_new_size = 200,
+ max_new_size = 2000
+ };
+
+ m_alloc.set_throw_prob(m_tp);
+ typename alloc_t::group_throw_prob_adjustor adjust(m_p_c->size());
+ const size_t new_size = m_g.get_unsigned_long(min_new_size, max_new_size);
+ m_p_c->resize(new_size);
+ const size_t actual_new_size = m_p_c->get_actual_size();
+ PB_DS_THROW_IF_FAILED(actual_new_size >= new_size,
+ actual_new_size << " " << new_size,
+ m_p_c, &m_native_c);
+ }
+ catch(...)
+ {
+ PB_DS_THROW_IF_FAILED(m_p_c->get_actual_size() == old_size,
+ m_p_c->get_actual_size() << " " << old_size,
+ m_p_c, &m_native_c);
+
+ done = false;
+ }
+
+ PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+ PB_DS_CANCEL_DESTRUCT_PRINT
+ return done;
+}
+
+
+// Get/Set load.
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+get_set_load()
+{
+ typedef
+ __gnu_pbds::detail::integral_constant<int, test_traits::get_set_load>
+ get_set_load_ind;
+
+ get_set_load_imp(get_set_load_ind());
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+get_set_load_imp(__gnu_pbds::detail::false_type)
+{ }
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+get_set_load_imp(__gnu_pbds::detail::true_type)
+{
+ PB_DS_TRACE("get_set_load");
+ PB_DS_SET_DESTRUCT_PRINT
+ m_p_c->get_load();
+ m_alloc.set_throw_prob(1);
+ typename alloc_t::group_throw_prob_adjustor adjust(m_p_c->size());
+ const float min_load = static_cast<float>(0.05);
+ const float max_load = static_cast<float>(0.9);
+
+ const float new_load = static_cast<float>(m_g.get_prob() * (max_load - min_load) + min_load);
+
+ m_p_c->set_load(new_load);
+ PB_DS_THROW_IF_FAILED(m_p_c->get_load() == new_load, "", m_p_c, &m_native_c);
+ PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+ PB_DS_CANCEL_DESTRUCT_PRINT
+}
+
+
+// Get/Set loads.
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+get_set_loads()
+{
+ typedef
+ __gnu_pbds::detail::integral_constant<int, test_traits::get_set_loads>
+ get_set_loads_ind;
+
+ return get_set_loads_imp(get_set_loads_ind());
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+get_set_loads_imp(__gnu_pbds::detail::false_type)
+{
+ return true;
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+get_set_loads_imp(__gnu_pbds::detail::true_type)
+{
+ PB_DS_TRACE("get_set_loads");
+ bool done = true;
+ PB_DS_SET_DESTRUCT_PRINT
+ const std::pair<float, float> old_loads = m_p_c->get_loads();
+
+ try
+ {
+ m_alloc.set_throw_prob(m_tp);
+
+ typename alloc_t::group_throw_prob_adjustor adjust(m_p_c->size());
+
+ const float min_min_load = static_cast<float>(0.05);
+ const float max_min_load = static_cast<float>(0.2);
+
+ const float new_min_load =
+ static_cast<float>(m_g.get_prob()* (max_min_load - min_min_load) +
+ min_min_load);
+
+ const float new_max_load = static_cast<float>(new_min_load* 2.5);
+ PB_DS_THROW_IF_FAILED(new_max_load < 1, new_max_load, m_p_c, &m_native_c);
+ m_p_c->set_loads(std::make_pair(new_min_load, new_max_load));
+ }
+ catch(...)
+ {
+ PB_DS_THROW_IF_FAILED(old_loads == m_p_c->get_loads(),
+ old_loads.first << " " << old_loads.second << " " <<
+ m_p_c->get_loads().first << " " <<
+ m_p_c->get_loads().second,
+ m_p_c, &m_native_c);
+
+ done = false;
+ }
+
+ PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+ PB_DS_CANCEL_DESTRUCT_PRINT
+ return done;
+}
+
+// Diagnostics.
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+print_container(const native_type& r_cnt, std::ostream& r_os) const
+{
+ m_alloc.set_throw_prob(0);
+ typename native_type::const_iterator it = r_cnt.begin();
+ while (it != r_cnt.end())
+ {
+ r_os << test_traits::val_to_string(*it) + "\n";
+ ++it;
+ }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+print_container(const cntnr& r_cnt, std::ostream& r_os) const
+{
+ m_alloc.set_throw_prob(0);
+ typename cntnr::const_iterator it = r_cnt.begin();
+ while (it != r_cnt.end())
+ {
+ r_os << test_traits::val_to_string(*it) + "\n";
+ ++it;
+ }
+}
+
+#endif
+++ /dev/null
-// -*- C++ -*-
-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License as published by the Free Software
-// Foundation; either version 2, or (at your option) any later
-// version.
-
-// This library is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this library; see the file COPYING. If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-
-// As a special exception, you may use this file as part of a free
-// software library without restriction. Specifically, if other files
-// instantiate templates or use macros or inline functions from this
-// file, or you compile this file and link it with other files to
-// produce an executable, this file does not by itself cause the
-// resulting executable to be covered by the GNU General Public
-// License. This exception does not however invalidate any other
-// reasons why the executable file might be covered by the GNU General
-// Public License.
-
-// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
-
-// Permission to use, copy, modify, sell, and distribute this software
-// is hereby granted without fee, provided that the above copyright
-// notice appears in all copies, and that both that copyright notice
-// and this permission notice appear in supporting documentation. None
-// of the above authors, nor IBM Haifa Research Laboratories, make any
-// representation about the suitability of this software for any
-// purpose. It is provided "as is" without express or implied
-// warranty.
-
-/**
- * @file clear_fn_imps.hpp
- * Containsert a random regression test for a specific container type.
- */
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-clear()
-{
- m_p_c->clear();
-
- m_native_c.clear();
-
- return (true);
-}
-
+++ /dev/null
-// -*- C++ -*-
-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License as published by the Free Software
-// Foundation; either version 2, or (at your option) any later
-// version.
-
-// This library is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this library; see the file COPYING. If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-
-// As a special exception, you may use this file as part of a free
-// software library without restriction. Specifically, if other files
-// instantiate templates or use macros or inline functions from this
-// file, or you compile this file and link it with other files to
-// produce an executable, this file does not by itself cause the
-// resulting executable to be covered by the GNU General Public
-// License. This exception does not however invalidate any other
-// reasons why the executable file might be covered by the GNU General
-// Public License.
-
-// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
-
-// Permission to use, copy, modify, sell, and distribute this software
-// is hereby granted without fee, provided that the above copyright
-// notice appears in all copies, and that both that copyright notice
-// and this permission notice appear in supporting documentation. None
-// of the above authors, nor IBM Haifa Research Laboratories, make any
-// representation about the suitability of this software for any
-// purpose. It is provided "as is" without express or implied
-// warranty.
-
-/**
- * @file cmp_fn_imps.hpp
- * Containsert a random regression test for a specific container type.
- */
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-cmp(const Cntnr& r_c, const native_type& r_native_c, const std::string& r_call_fn)
-{
- m_alloc.set_throw_prob(1);
-
- const size_t size = r_c.size();
- const size_t native_size = r_native_c.size();
-
- PB_DS_THROW_IF_FAILED(
- size == native_size,
- static_cast<unsigned long>(size) << " " <<
- static_cast<unsigned long>(native_size),
- & r_c,
- & r_native_c);
-
- const bool empty = r_c.empty();
- const bool native_empty = r_native_c.empty();
-
- PB_DS_THROW_IF_FAILED(
- empty == native_empty,
- empty << " " << native_empty,
- & r_c,
- & r_native_c);
-
- try
- {
- basic_cmp_(r_c, r_native_c);
-
- cmp_(r_c, r_native_c);
- }
- catch(...)
- {
- PB_DS_THROW_IF_FAILED( false, "call-fn: " + r_call_fn, & r_c, & r_native_c);
- }
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-basic_cmp_(const Cntnr& r_c, const native_type& r_native_c)
-{
- PB_DS_SET_DESTRUCT_PRINT
-
- if (static_cast<size_t>(std::distance(r_c.begin(), r_c.end())) !=
- r_c.size())
- PB_DS_THROW_IF_FAILED(
- false,
- static_cast<unsigned long>(
- std::distance(r_c.begin(), r_c.end())) <<
- " " << static_cast<unsigned long>(r_c.size()),
- & r_c,
- & r_native_c);
-
- typename native_type::const_iterator it = r_native_c.begin();
-
- while (it != r_native_c.end())
- {
- typename native_type::key_type native_key =
- test_traits::extract_native_key(*it);
-
- m_alloc.set_throw_prob(0);
-
- const key_type k = native_key;
-
- m_alloc.set_throw_prob(1);
-
- typename cntnr::const_point_iterator found_it = r_c.find(k);
-
- PB_DS_THROW_IF_FAILED(
- found_it != r_c.end(),
- test_traits::native_val_to_string(*it),
- & r_c,
- & r_native_c);
-
- if (!test_traits::cmp(*found_it, * it))
- PB_DS_THROW_IF_FAILED( false, "", & r_c, & r_native_c);
-
- ++it;
- }
-
- PB_DS_CANCEL_DESTRUCT_PRINT
- }
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-cmp_(const Cntnr& r_c, const native_type& r_native_c)
-{
- enum
- {
- order_preserving =
- container_traits::order_preserving,
- back_order_preserving =
- container_traits::order_preserving&&
- !__gnu_pbds::detail::is_same<
- typename std::iterator_traits<
- typename cntnr::const_iterator>::iterator_category,
- std::forward_iterator_tag>::value,
- reverse_iteration = container_traits::reverse_iteration,
- order_statistics = test_traits::order_statistics,
- prefix_search = test_traits::prefix_search,
- has_mapped = !__gnu_pbds::detail::is_same<
- typename Cntnr::mapped_type,
- __gnu_pbds::null_mapped_type>::value
- };
-
- order_preserving_cmp_imp(r_c, r_native_c,
- __gnu_pbds::detail::integral_constant<int,order_preserving>());
-
- back_order_preserving_cmp_imp(r_c, r_native_c,
- __gnu_pbds::detail::integral_constant<int,back_order_preserving>());
-
- order_statistics_cmp_imp(r_c, r_native_c,
- __gnu_pbds::detail::integral_constant<int,order_statistics>());
-
- prefix_search_cmp_imp(r_c, r_native_c,
- __gnu_pbds::detail::integral_constant<int,prefix_search>());
-
- reverse_iteration_cmp_imp(r_c, r_native_c,
- __gnu_pbds::detail::integral_constant<int,reverse_iteration>());
-
- lower_bound_cmp_imp(r_c, r_native_c,
- __gnu_pbds::detail::integral_constant<int,order_preserving>());
-
- upper_bound_cmp_imp(r_c, r_native_c,
- __gnu_pbds::detail::integral_constant<int,order_preserving>());
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-order_preserving_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, __gnu_pbds::detail::false_type)
-{ }
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-order_preserving_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, __gnu_pbds::detail::true_type)
-{
- PB_DS_SET_DESTRUCT_PRINT
-
- typename cntnr::const_iterator b = r_c.begin();
- typename cntnr::const_iterator e = r_c.end();
-
- typename native_type::const_iterator native_b = r_native_c.begin();
- typename native_type::const_iterator native_e = r_native_c.end();
-
- try
- {
- it_cmp_imp(b, e, native_b, native_e);
- }
- catch(...)
- {
- PB_DS_THROW_IF_FAILED( false, "", & r_c, & r_native_c)
- }
-
- try
- {
- back_it_cmp_imp(b, e, native_b, native_e);
- }
- catch(...)
- {
- PB_DS_THROW_IF_FAILED( false, "", & r_c, & r_native_c)
- }
-
- PB_DS_CANCEL_DESTRUCT_PRINT
- }
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-back_order_preserving_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, __gnu_pbds::detail::false_type)
-{ }
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-back_order_preserving_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, __gnu_pbds::detail::true_type)
-{
- PB_DS_SET_DESTRUCT_PRINT
-
- typename cntnr::const_iterator b = r_c.begin();
- typename cntnr::const_iterator e = r_c.end();
-
- typename native_type::const_iterator native_b = r_native_c.begin();
- typename native_type::const_iterator native_e = r_native_c.end();
-
- it_cmp_imp(b, e, native_b, native_e);
-
- PB_DS_CANCEL_DESTRUCT_PRINT
- }
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-reverse_iteration_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, __gnu_pbds::detail::false_type)
-{ }
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-reverse_iteration_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, __gnu_pbds::detail::true_type)
-{
- PB_DS_SET_DESTRUCT_PRINT
-
- typename cntnr::const_reverse_iterator b = r_c.rbegin();
- typename cntnr::const_reverse_iterator e = r_c.rend();
-
- typename native_type::const_reverse_iterator native_b = r_native_c.rbegin();
- typename native_type::const_reverse_iterator native_e = r_native_c.rend();
-
- try
- {
- it_cmp_imp(b, e, native_b, native_e);
- }
- catch(...)
- {
- PB_DS_THROW_IF_FAILED( false, "", & r_c, & r_native_c)
- }
-
- try
- {
- back_it_cmp_imp(b, e, native_b, native_e);
- }
- catch(...)
- {
- PB_DS_THROW_IF_FAILED( false, "", & r_c, & r_native_c)
- }
-
- PB_DS_CANCEL_DESTRUCT_PRINT
- }
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-order_statistics_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, __gnu_pbds::detail::false_type)
-{ }
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-order_statistics_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, __gnu_pbds::detail::true_type)
-{
- {
- m_alloc.set_throw_prob(0);
-
- const key_type k =
- test_traits::generate_key(m_g, m_m);
-
- m_alloc.set_throw_prob(1);
-
- const size_type order = r_c.order_of_key(k);
-
- const size_type native_order = std::distance(
- r_native_c.begin(),
- r_native_c.lower_bound(test_traits::native_key(k)));
-
- PB_DS_THROW_IF_FAILED(
- order == native_order,
- test_traits::key_to_string(k) << " " <<
- static_cast<unsigned long>(order) << " " <<
- static_cast<unsigned long>(native_order),
- & r_c,
- & r_native_c);
- }
-
- const size_type rand_ord =
- static_cast<size_t>(m_g.get_unsigned_long(
- 0,
- 2* static_cast<unsigned long>(m_m)));
-
- typename cntnr::const_iterator it =
- r_c.find_by_order(rand_ord);
-
- typename native_type::const_iterator native_it =
- r_native_c.begin();
-
- std::advance(native_it, std::min(rand_ord, r_native_c.size()));
-
- if (it == r_c.end()&& native_it != r_native_c.end())
- PB_DS_THROW_IF_FAILED(
- false,
- static_cast<unsigned long>(rand_ord),
- m_p_c,
- & m_native_c);
-
- if (it != r_c.end()&& native_it == r_native_c.end())
- PB_DS_THROW_IF_FAILED(
- false,
- static_cast<unsigned long>(rand_ord),
- m_p_c,
- & m_native_c);
-
- if (it != r_c.end()&& native_it != r_native_c.end())
- PB_DS_THROW_IF_FAILED(
- test_traits::cmp(*it, * native_it),
- static_cast<unsigned long>(rand_ord),
- m_p_c,
- & m_native_c);
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-prefix_search_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, __gnu_pbds::detail::false_type)
-{ }
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-prefix_search_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, __gnu_pbds::detail::true_type)
-{
- PB_DS_SET_DESTRUCT_PRINT
-
- m_alloc.set_throw_prob(0);
-
- const key_type k =
- test_traits::generate_key(m_g, m_m);
-
- m_alloc.set_throw_prob(1);
-
- try
- {
- typedef
- std::pair<
- typename Cntnr::const_iterator,
- typename Cntnr::const_iterator>
- pref_ret_t;
-
- const pref_ret_t pref_ret = r_c.prefix_range(k);
-
- typename native_type::const_iterator native_start_it =
- r_native_c.begin();
-
- while (native_start_it != r_native_c.end()&&
- !test_traits::prefix_match(
- k,
- test_traits::extract_native_key(*native_start_it)))
- ++native_start_it;
-
- typename native_type::const_iterator native_end_it =
- native_start_it;
-
- do
- {
- if (native_end_it != r_native_c.end())
- ++native_end_it;
- }
- while (native_end_it != r_native_c.end()&&
- test_traits::prefix_match(
- k,
- test_traits::extract_native_key(*native_end_it)));
-
- it_cmp_imp( pref_ret.first, pref_ret.second, native_start_it, native_end_it);
- }
- catch(...)
- {
- PB_DS_THROW_IF_FAILED(
- false,
- "prefix key " << k,
- & r_c,
- & r_native_c);
- }
-
- PB_DS_CANCEL_DESTRUCT_PRINT
- }
-
-PB_DS_CLASS_T_DEC
-template<typename Const_It, class Const_Native_It>
-void
-PB_DS_CLASS_C_DEC::
-it_cmp_imp(Const_It b, Const_It e, Const_Native_It native_b, Const_Native_It native_e)
-{
- PB_DS_SET_DESTRUCT_PRINT
-
- if (std::distance(b, e) != std::distance(native_b, native_e))
- {
- const size_t dist = std::distance(b, e);
-
- const size_t native_dist = std::distance(native_b, native_e);
-
- PB_DS_THROW_IF_FAILED(
- false,
- static_cast<unsigned long>(dist) << " "
- << static_cast<unsigned long>(native_dist),
- m_p_c,
- & m_native_c);
- }
-
- while (b != e)
- {
- PB_DS_THROW_IF_FAILED( native_b != native_e, "", m_p_c, & m_native_c);
-
- if (!test_traits::cmp(*b, * native_b))
- PB_DS_THROW_IF_FAILED(
- false,
- test_traits::val_to_string(*b) << " " <<
- test_traits::val_to_string(*native_b),
- m_p_c,
- & m_native_c);
-
- ++b;
- ++native_b;
- }
-
- PB_DS_THROW_IF_FAILED( native_b == native_e, "", m_p_c, & m_native_c);
-
- PB_DS_CANCEL_DESTRUCT_PRINT
- }
-
-PB_DS_CLASS_T_DEC
-template<typename Const_It, class Const_Native_It>
-void
-PB_DS_CLASS_C_DEC::
-back_it_cmp_imp(Const_It b, Const_It e, Const_Native_It native_b, Const_Native_It native_e)
-{
- PB_DS_SET_DESTRUCT_PRINT
-
- while (b != e)
- {
- PB_DS_THROW_IF_FAILED(
- native_b != native_e,
- test_traits::val_to_string(*native_e),
- m_p_c,
- & m_native_c);
-
- --e;
- --native_e;
-
- PB_DS_THROW_IF_FAILED(
- test_traits::cmp(*e, * native_e),
- test_traits::val_to_string(*e) <<
- test_traits::val_to_string(*native_e),
- m_p_c,
- & m_native_c);
- }
-
- PB_DS_THROW_IF_FAILED(
- native_b == native_e,
- test_traits::val_to_string(*native_e),
- m_p_c,
- & m_native_c);
-
- PB_DS_CANCEL_DESTRUCT_PRINT
- }
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-lower_bound_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, __gnu_pbds::detail::false_type)
-{ }
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-lower_bound_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, __gnu_pbds::detail::true_type)
-{
- PB_DS_SET_DESTRUCT_PRINT
-
- m_alloc.set_throw_prob(0);
-
- const key_type k =
- test_traits::generate_key(m_g, m_m);
-
- m_alloc.set_throw_prob(1);
-
- typename cntnr::const_iterator it = r_c.lower_bound(k);
-
- typename native_type::key_type native_k = test_traits::native_key(k);
-
- typename native_type::const_iterator native_it =
- r_native_c.lower_bound(native_k);
-
- if (it != r_c.end()&& native_it == r_native_c.end())
- PB_DS_THROW_IF_FAILED(
- "",
- "it: " + test_traits::val_to_string(*it) + "\n\n",
- & r_c,
- & r_native_c);
-
- if (it == r_c.end()&& native_it != r_native_c.end())
- PB_DS_THROW_IF_FAILED(
- "",
- "native_it: " + test_traits::val_to_string(*native_it) + "\n\n",
- & r_c,
- & r_native_c);
-
- if (it != r_c.end()&& !test_traits::cmp(*it, * native_it))
- PB_DS_THROW_IF_FAILED(
- false,
- "key: " + test_traits::key_to_string(k) + "\n\n" +
- "it: " + test_traits::val_to_string(*it) + "\n\n" +
- "native_it: " + test_traits::val_to_string(*native_it) + "\n\n",
- & r_c,
- & r_native_c);
-
- PB_DS_CANCEL_DESTRUCT_PRINT
- }
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-upper_bound_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, __gnu_pbds::detail::false_type)
-{ }
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-upper_bound_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, __gnu_pbds::detail::true_type)
-{
- PB_DS_SET_DESTRUCT_PRINT
-
- m_alloc.set_throw_prob(0);
-
- const key_type k =
- test_traits::generate_key(m_g, m_m);
-
- m_alloc.set_throw_prob(1);
-
- typename cntnr::const_iterator it = r_c.upper_bound(k);
-
- typename native_type::key_type native_k = test_traits::native_key(k);
-
- typename native_type::const_iterator native_it =
- r_native_c.upper_bound(native_k);
-
- if (it == r_c.end()&& native_it != r_native_c.end())
- PB_DS_THROW_IF_FAILED(
- false,
- "key: " + test_traits::key_to_string(k) + "\n\n" +
- "native_it: " + test_traits::val_to_string(*native_it) + "\n\n",
- & r_c,
- & r_native_c);
-
- if (it != r_c.end()&& native_it == r_native_c.end())
- PB_DS_THROW_IF_FAILED(
- false,
- "key: " + test_traits::key_to_string(k) + "\n\n" +
- "it: " + test_traits::val_to_string(*it) + "\n\n",
- & r_c,
- & r_native_c);
-
- if (it != r_c.end()&& !test_traits::cmp(*it, * native_it))
- PB_DS_THROW_IF_FAILED(
- false,
- "key: " + test_traits::key_to_string(k) + "\n\n" +
- "it: " + test_traits::val_to_string(*it) + "\n\n" +
- "native_it: " + test_traits::val_to_string(*native_it) + "\n\n",
- & r_c,
- & r_native_c);
-
- PB_DS_CANCEL_DESTRUCT_PRINT
- }
+++ /dev/null
-// -*- C++ -*-
-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License as published by the Free Software
-// Foundation; either version 2, or (at your option) any later
-// version.
-
-// This library is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this library; see the file COPYING. If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-
-// As a special exception, you may use this file as part of a free
-// software library without restriction. Specifically, if other files
-// instantiate templates or use macros or inline functions from this
-// file, or you compile this file and link it with other files to
-// produce an executable, this file does not by itself cause the
-// resulting executable to be covered by the GNU General Public
-// License. This exception does not however invalidate any other
-// reasons why the executable file might be covered by the GNU General
-// Public License.
-
-// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
-
-// Permission to use, copy, modify, sell, and distribute this software
-// is hereby granted without fee, provided that the above copyright
-// notice appears in all copies, and that both that copyright notice
-// and this permission notice appear in supporting documentation. None
-// of the above authors, nor IBM Haifa Research Laboratories, make any
-// representation about the suitability of this software for any
-// purpose. It is provided "as is" without express or implied
-// warranty.
-
-/**
- * @file constructor_destructor_fn_imps.hpp
- * Containsert a random regression test for a specific container type.
- */
-
-PB_DS_CLASS_T_DEC
-PB_DS_CLASS_C_DEC::
-container_rand_regression_test(unsigned long seed, size_t n, size_t m,
- double tp, double ip, double ep, double cp,
- double mp, bool disp)
-: m_seed((seed == 0) ? twister_rand_gen::get_time_determined_seed() : seed),
- m_n(n), m_m(m), m_tp(tp), m_ip(ip), m_ep(ep), m_cp(cp), m_mp(mp),
- m_disp(disp), m_p_c(NULL)
-{ }
-
-PB_DS_CLASS_T_DEC
-PB_DS_CLASS_C_DEC::
-~container_rand_regression_test()
-{ }
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-default_constructor()
-{
- PB_DS_TRACE("default_constructor");
- bool done = true;
- m_alloc.set_throw_prob(m_tp);
-
- try
- {
- m_p_c = new Cntnr;
- }
- catch(__gnu_cxx::forced_exception_error&)
- {
- done = false;
- }
-
- if (m_p_c != NULL)
- PB_DS_COND_COMPARE(*m_p_c, m_native_c);
- return done;
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-swap()
-{
- PB_DS_TRACE("swap");
- m_alloc.set_throw_prob(0);
- Cntnr* p_c = new Cntnr;
- m_alloc.set_throw_prob(1);
- p_c->swap(*m_p_c);
- std::swap(p_c, m_p_c);
- delete p_c;
- PB_DS_COND_COMPARE(*m_p_c, m_native_c);
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-copy_constructor()
-{
- PB_DS_TRACE("copy_constructor");
- bool done = true;
- Cntnr* p_c = NULL;
- m_alloc.set_throw_prob(m_tp);
- typename alloc_t::group_throw_prob_adjustor adjust(m_p_c->size());
-
- try
- {
- p_c = new Cntnr(*m_p_c);
- std::swap(p_c, m_p_c);
- }
- catch(__gnu_cxx::forced_exception_error& )
- {
- done = false;
- }
-
- delete p_c;
- PB_DS_COND_COMPARE(*m_p_c, m_native_c);
- return done;
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-assignment_operator()
-{
- PB_DS_TRACE("assignment operator");
- bool done = true;
- Cntnr* p_c = NULL;
- m_alloc.set_throw_prob(m_tp);
- typename alloc_t::group_throw_prob_adjustor adjust(m_p_c->size());
-
- try
- {
- p_c = new Cntnr();
- * p_c =* m_p_c;
- std::swap(p_c, m_p_c);
- }
- catch(__gnu_cxx::forced_exception_error& )
- {
- done = false;
- }
-
- delete p_c;
- PB_DS_COND_COMPARE(*m_p_c, m_native_c);
- return done;
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-it_constructor()
-{
- PB_DS_TRACE("it_constructor");
- return it_constructor_imp(typename Cntnr::container_category());
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-it_constructor_imp(__gnu_pbds::cc_hash_tag)
-{
- bool done = true;
- Cntnr* p_c = NULL;
- m_alloc.set_throw_prob(m_tp);
- typename alloc_t::group_throw_prob_adjustor adjust(m_p_c->size());
-
- try
- {
- switch(get_next_sub_op(8))
- {
- case 0:
- p_c = new Cntnr(m_p_c->get_hash_fn());
- m_native_c.clear();
- break;
- case 1:
- p_c = new Cntnr(m_p_c->get_hash_fn(), m_p_c->get_eq_fn());
- m_native_c.clear();
- break;
- case 2:
- p_c = new Cntnr(m_p_c->get_hash_fn(), m_p_c->get_eq_fn(),
- m_p_c->get_comb_hash_fn());
- m_native_c.clear();
- break;
- case 3:
- p_c = new Cntnr(m_p_c->get_hash_fn(), m_p_c->get_eq_fn(),
- m_p_c->get_comb_hash_fn(),
- m_p_c->get_resize_policy());
- m_native_c.clear();
- break;
- case 4:
- p_c = new Cntnr(m_p_c->begin(), m_p_c->end());
- break;
- case 5:
- p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_hash_fn());
- break;
- case 6:
- p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_hash_fn(),
- m_p_c->get_eq_fn());
- break;
- case 7:
- p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_hash_fn(),
- m_p_c->get_eq_fn(), m_p_c->get_comb_hash_fn());
- break;
- case 8:
- p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_hash_fn(),
- m_p_c->get_eq_fn(), m_p_c->get_comb_hash_fn(),
- m_p_c->get_resize_policy());
- break;
- default:
- PB_DS_THROW_IF_FAILED(false, "", m_p_c, & m_native_c);
- };
- std::swap(p_c, m_p_c);
- }
- catch (__gnu_cxx::forced_exception_error&)
- {
- done = false;
- }
-
- delete p_c;
- PB_DS_COND_COMPARE(*m_p_c, m_native_c);
- return done;
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-it_constructor_imp(__gnu_pbds::gp_hash_tag)
-{
- bool done = true;
- Cntnr* p_c = NULL;
- m_alloc.set_throw_prob(m_tp);
- typename alloc_t::group_throw_prob_adjustor adjust(m_p_c->size());
-
- try
- {
- switch(get_next_sub_op(11))
- {
- case 0:
- p_c = new Cntnr(m_p_c->get_hash_fn());
- m_native_c.clear();
- break;
- case 1:
- p_c = new Cntnr(m_p_c->get_hash_fn(), m_p_c->get_eq_fn());
- m_native_c.clear();
- break;
- case 2:
- p_c = new Cntnr(m_p_c->get_hash_fn(), m_p_c->get_eq_fn(),
- m_p_c->get_comb_probe_fn());
- m_native_c.clear();
- break;
- case 3:
- p_c = new Cntnr(m_p_c->get_hash_fn(), m_p_c->get_eq_fn(),
- m_p_c->get_comb_probe_fn());
- m_native_c.clear();
- break;
- case 4:
- p_c = new Cntnr(m_p_c->get_hash_fn(), m_p_c->get_eq_fn(),
- m_p_c->get_comb_probe_fn(), m_p_c->get_probe_fn());
- m_native_c.clear();
- break;
- case 5:
- p_c = new Cntnr(m_p_c->get_hash_fn(), m_p_c->get_eq_fn(),
- m_p_c->get_comb_probe_fn(), m_p_c->get_probe_fn(),
- m_p_c->get_resize_policy());
- m_native_c.clear();
- break;
- case 6:
- p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_hash_fn());
- break;
- case 7:
- p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_hash_fn(),
- m_p_c->get_eq_fn());
- break;
- case 8:
- p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_hash_fn(),
- m_p_c->get_eq_fn(), m_p_c->get_comb_probe_fn());
- break;
- case 9:
- p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_hash_fn(),
- m_p_c->get_eq_fn(), m_p_c->get_comb_probe_fn());
- break;
- case 10:
- p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_hash_fn(),
- m_p_c->get_eq_fn(), m_p_c->get_comb_probe_fn(),
- m_p_c->get_probe_fn());
- break;
- case 11:
- p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_hash_fn(),
- m_p_c->get_eq_fn(), m_p_c->get_comb_probe_fn(),
- m_p_c->get_probe_fn(), m_p_c->get_resize_policy());
- break;
- default:
- PB_DS_THROW_IF_FAILED(false, "", m_p_c, & m_native_c);
- };
- std::swap(p_c, m_p_c);
- }
- catch (__gnu_cxx::forced_exception_error&)
- {
- done = false;
- }
-
- delete p_c;
- PB_DS_COND_COMPARE(*m_p_c, m_native_c);
- return done;
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-it_constructor_imp(__gnu_pbds::tree_tag)
-{
- bool done = true;
- Cntnr* p_c = NULL;
- m_alloc.set_throw_prob(m_tp);
- typename alloc_t::group_throw_prob_adjustor adjust(m_p_c->size());
-
- try
- {
- switch(get_next_sub_op(2))
- {
- case 0:
- p_c = new Cntnr(m_p_c->get_cmp_fn());
- m_native_c.clear();
- break;
- case 1:
- p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_cmp_fn());
- break;
- default:
- PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
- };
- std::swap(p_c, m_p_c);
- }
- catch (__gnu_cxx::forced_exception_error&)
- {
- done = false;
- }
-
- delete p_c;
- PB_DS_COND_COMPARE(*m_p_c, m_native_c);
- return done;
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-it_constructor_imp(__gnu_pbds::list_update_tag)
-{
- bool done = true;
- Cntnr* p_c = NULL;
- m_alloc.set_throw_prob(m_tp);
- typename alloc_t::group_throw_prob_adjustor adjust(m_p_c->size());
-
- try
- {
- p_c = new Cntnr(m_p_c->begin(), m_p_c->end());
- std::swap(p_c, m_p_c);
- }
- catch (__gnu_cxx::forced_exception_error&)
- {
- done = false;
- }
-
- delete p_c;
- PB_DS_COND_COMPARE(*m_p_c, m_native_c);
- return done;
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-it_constructor_imp(__gnu_pbds::pat_trie_tag)
-{
- bool done = true;
- Cntnr* p_c = NULL;
- m_alloc.set_throw_prob(m_tp);
- typename alloc_t::group_throw_prob_adjustor adjust(m_p_c->size());
-
- try
- {
- switch(get_next_sub_op(2))
- {
- case 0:
- p_c = new Cntnr(m_p_c->get_e_access_traits());
- m_native_c.clear();
- break;
- case 1:
- p_c = new Cntnr(m_p_c->begin(), m_p_c->end(),
- m_p_c->get_e_access_traits());
- break;
- default:
- PB_DS_THROW_IF_FAILED(false, "", m_p_c, & m_native_c);
- };
-
- std::swap(p_c, m_p_c);
- }
- catch (__gnu_cxx::forced_exception_error&)
- {
- done = false;
- }
-
- delete p_c;
- PB_DS_COND_COMPARE(*m_p_c, m_native_c);
- return done;
-}
-
+++ /dev/null
-// -*- C++ -*-
-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License as published by the Free Software
-// Foundation; either version 2, or (at your option) any later
-// version.
-
-// This library is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this library; see the file COPYING. If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-
-// As a special exception, you may use this file as part of a free
-// software library without restriction. Specifically, if other files
-// instantiate templates or use macros or inline functions from this
-// file, or you compile this file and link it with other files to
-// produce an executable, this file does not by itself cause the
-// resulting executable to be covered by the GNU General Public
-// License. This exception does not however invalidate any other
-// reasons why the executable file might be covered by the GNU General
-// Public License.
-
-// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
-
-// Permission to use, copy, modify, sell, and distribute this software
-// is hereby granted without fee, provided that the above copyright
-// notice appears in all copies, and that both that copyright notice
-// and this permission notice appear in supporting documentation. None
-// of the above authors, nor IBM Haifa Research Laboratories, make any
-// representation about the suitability of this software for any
-// purpose. It is provided "as is" without express or implied
-// warranty.
-
-/**
- * @file defs_fn_imps.hpp
- * Containsert a random regression test for a specific container type.
- */
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-defs()
-{
- // General container types.
-
- typedef typename Cntnr::size_type test_size_type;
-
- typedef typename Cntnr::difference_type difference_type;
-
- key_defs();
-
- mapped_defs();
-
- value_defs();
-
- iterator_defs();
-
- node_iterator_defs(__gnu_pbds::detail::integral_constant<int,
- container_traits::order_preserving>());
-
- policy_defs();
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-key_defs()
-{
- typedef typename Cntnr::key_type test_key_type;
-
- typedef typename Cntnr::key_reference test_key_reference;
-
- typedef typename Cntnr::const_key_reference test_const_key_reference;
-
- typedef typename Cntnr::key_pointer test_key_pointer;
-
- typedef typename Cntnr::const_key_pointer test_const_key_pointer;
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-mapped_defs()
-{
- typedef typename Cntnr::mapped_type test_mapped_type;
-
- typedef typename Cntnr::mapped_reference test_mapped_reference;
-
- typedef
- typename Cntnr::const_mapped_reference
- test_const_mapped_reference;
-
- typedef typename Cntnr::mapped_pointer test_mapped_pointer;
-
- typedef typename Cntnr::const_mapped_pointer test_const_mapped_pointer;
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-value_defs()
-{
- typedef typename Cntnr::value_type test_value_type;
-
- typedef typename Cntnr::reference test_reference;
-
- typedef typename Cntnr::const_reference test_const_reference;
-
- typedef typename Cntnr::pointer test_pointer;
-
- typedef typename Cntnr::const_pointer test_const_pointer;
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-ds_defs()
-{
- typedef __gnu_pbds::container_traits< Cntnr> test_container_traits;
-
- typedef typename test_container_traits::container_category test_container_category;
-
- typedef
- typename test_container_traits::invalidation_guarantee
- test_invalidation_guarantee;
-
- enum
- {
- test_order_preserving =
- test_container_traits::order_preserving
- };
-
- enum
- {
- test_erase_can_throw =
- test_container_traits::erase_can_throw
- };
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-iterator_defs()
-{
- typedef typename Cntnr::point_iterator test_point_iterator;
-
- typedef typename Cntnr::const_point_iterator const_test_point_iterator;
-
- typedef typename Cntnr::iterator test_iterator;
-
- typedef typename Cntnr::const_iterator const_test_iterator;
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-node_iterator_defs(__gnu_pbds::detail::false_type)
-{ }
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-node_iterator_defs(__gnu_pbds::detail::true_type)
-{
- typedef typename Cntnr::node_iterator test_node_iterator;
-
- typedef typename Cntnr::const_node_iterator test_const_node_iterator;
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-policy_defs()
-{
- typedef typename Cntnr::allocator_type test_allocator;
-
- policy_defs(typename Cntnr::container_category());
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-policy_defs(__gnu_pbds::basic_hash_tag)
-{
- typedef typename Cntnr::hash_fn test_hash_fn;
-
- typedef typename Cntnr::eq_fn test_eq_fn;
-
- typedef typename Cntnr::resize_policy test_resize_policy;
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-policy_defs(__gnu_pbds::cc_hash_tag)
-{
- policy_defs(__gnu_pbds::basic_hash_tag());
-
- typedef typename Cntnr::comb_hash_fn test_comb_hash_fn;
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-policy_defs(__gnu_pbds::gp_hash_tag)
-{
- policy_defs(__gnu_pbds::basic_hash_tag());
-
- typedef typename Cntnr::comb_probe_fn test_comb_probe_fn;
-
- typedef typename Cntnr::probe_fn test_probe_fn;
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-policy_defs(__gnu_pbds::tree_tag)
-{
- typedef typename Cntnr::cmp_fn test_cmp_fn;
-
- typedef typename Cntnr::node_update test_node_update;
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-policy_defs(__gnu_pbds::list_update_tag)
-{
- typedef typename Cntnr::eq_fn test_eq_fn;
-
- typedef typename Cntnr::update_policy test_update_policy;
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-policy_defs(__gnu_pbds::pat_trie_tag)
-{
- typedef typename Cntnr::e_access_traits e_access_traits;
-}
+++ /dev/null
-// -*- C++ -*-
-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License as published by the Free Software
-// Foundation; either version 2, or (at your option) any later
-// version.
-
-// This library is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this library; see the file COPYING. If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-
-// As a special exception, you may use this file as part of a free
-// software library without restriction. Specifically, if other files
-// instantiate templates or use macros or inline functions from this
-// file, or you compile this file and link it with other files to
-// produce an executable, this file does not by itself cause the
-// resulting executable to be covered by the GNU General Public
-// License. This exception does not however invalidate any other
-// reasons why the executable file might be covered by the GNU General
-// Public License.
-
-// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
-
-// Permission to use, copy, modify, sell, and distribute this software
-// is hereby granted without fee, provided that the above copyright
-// notice appears in all copies, and that both that copyright notice
-// and this permission notice appear in supporting documentation. None
-// of the above authors, nor IBM Haifa Research Laboratories, make any
-// representation about the suitability of this software for any
-// purpose. It is provided "as is" without express or implied
-// warranty.
-
-/**
- * @file diagnostic_fn_imps.hpp
- * Containsert a random regression test for a specific container type.
- */
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-print_container(const native_type& r_cnt, std::ostream& r_os /*= std::cerr*/) const
-{
- m_alloc.set_throw_prob(0);
-
- typename native_type::const_iterator it = r_cnt.begin();
-
- while (it != r_cnt.end())
- {
- r_os << test_traits::val_to_string(*it) + "\n";
-
- ++it;
- }
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-print_container(const cntnr& r_cnt, std::ostream& r_os /*= std::cerr*/) const
-{
- m_alloc.set_throw_prob(0);
-
- typename cntnr::const_iterator it = r_cnt.begin();
-
- while (it != r_cnt.end())
- {
- r_os << test_traits::val_to_string(*it) + "\n";
-
- ++it;
- }
-}
+++ /dev/null
-// -*- C++ -*-
-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License as published by the Free Software
-// Foundation; either version 2, or (at your option) any later
-// version.
-
-// This library is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this library; see the file COPYING. If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-
-// As a special exception, you may use this file as part of a free
-// software library without restriction. Specifically, if other files
-// instantiate templates or use macros or inline functions from this
-// file, or you compile this file and link it with other files to
-// produce an executable, this file does not by itself cause the
-// resulting executable to be covered by the GNU General Public
-// License. This exception does not however invalidate any other
-// reasons why the executable file might be covered by the GNU General
-// Public License.
-
-// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
-
-// Permission to use, copy, modify, sell, and distribute this software
-// is hereby granted without fee, provided that the above copyright
-// notice appears in all copies, and that both that copyright notice
-// and this permission notice appear in supporting documentation. None
-// of the above authors, nor IBM Haifa Research Laboratories, make any
-// representation about the suitability of this software for any
-// purpose. It is provided "as is" without express or implied
-// warranty.
-
-/**
- * @file erase_fn_imps.hpp
- * Containsert a random regression test for a specific container type.
- */
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-erase()
-{
- PB_DS_TRACE("erase");
-
- bool done = true;
-
- PB_DS_SET_DESTRUCT_PRINT
-
- m_alloc.set_throw_prob(0);
-
- const key_type k =
- test_traits::generate_key(m_g, m_m);
-
- m_alloc.set_throw_prob(m_tp);
-
- try
- {
- const bool cntnd = m_p_c->find(k) != m_p_c->end();
-
- PB_DS_THROW_IF_FAILED(
- cntnd ==(m_native_c.find(test_traits::native_key(k)) != m_native_c.end()),
- test_traits::key_to_string(k),
- m_p_c,
- & m_native_c);
-
- const bool ersd = m_p_c->erase(k);
-
- const bool native_ersd =
- m_native_c.erase(test_traits::native_key(k)) != 0;
-
- PB_DS_THROW_IF_FAILED(
- ersd == native_ersd,
- ersd << " " << native_ersd,
- m_p_c,
- & m_native_c);
-
- PB_DS_THROW_IF_FAILED(
- m_p_c->find(k) == m_p_c->end(),
- "",
- m_p_c,
- & m_native_c);
- }
- catch(__gnu_cxx::forced_exception_error& )
- {
- done = false;
-
- PB_DS_THROW_IF_FAILED( container_traits::erase_can_throw, container_traits::erase_can_throw, m_p_c, & m_native_c);
- }
-
- PB_DS_COND_COMPARE(*m_p_c, m_native_c);
-
- PB_DS_CANCEL_DESTRUCT_PRINT
-
- return (done);
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-erase_if()
-{
- PB_DS_TRACE("erase_if");
-
- bool done = true;
-
- PB_DS_SET_DESTRUCT_PRINT
-
- try
- {
- typedef
- typename std::iterator_traits<
- typename cntnr::iterator>::reference
- it_const_reference;
-
- typedef
- typename test_traits::template erase_if_fn<
- value_type>
- erase_if_fn_t;
-
- m_alloc.set_throw_prob(m_tp);
-
- const size_t ersd =
- m_p_c->erase_if(erase_if_fn_t());
-
- const size_t native_ersd =
- test_traits::erase_if(m_native_c);
-
- PB_DS_THROW_IF_FAILED(
- ersd == native_ersd,
- static_cast<unsigned long>(ersd) << " " <<
- static_cast<unsigned long>(native_ersd),
- m_p_c,
- & m_native_c);
- }
- catch(__gnu_cxx::forced_exception_error& )
- {
- done = false;
-
- PB_DS_THROW_IF_FAILED( container_traits::erase_can_throw, container_traits::erase_can_throw, m_p_c, & m_native_c);
- }
-
- PB_DS_COND_COMPARE(*m_p_c, m_native_c);
-
- PB_DS_CANCEL_DESTRUCT_PRINT
-
- return (done);
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-erase_it()
-{
- enum
- {
- erase_iterators =
- container_traits::order_preserving
- };
-
- return (erase_it_imp(__gnu_pbds::detail::integral_constant<int,erase_iterators>()));
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-erase_it_imp(__gnu_pbds::detail::false_type)
-{
- return (true);
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-erase_it_imp(__gnu_pbds::detail::true_type)
-{
- PB_DS_TRACE("erase_it");
-
- bool done = true;
-
- PB_DS_SET_DESTRUCT_PRINT
-
- try
- {
- m_alloc.set_throw_prob(0);
-
- const key_type k =
- test_traits::generate_key(m_g, m_m);
-
- m_alloc.set_throw_prob(m_tp);
-
- typename cntnr::iterator found_it = m_p_c->find(k);
-
- typename native_type::iterator native_it = m_native_c.find(
- test_traits::native_key(k));
-
- const bool found = found_it != m_p_c->end();
- const bool native_found = native_it != m_native_c.end();
-
- PB_DS_THROW_IF_FAILED(
- found == native_found,
- found << " " << native_found,
- m_p_c,
- & m_native_c);
-
- typename cntnr::const_iterator next_it = found_it;
- if (next_it != m_p_c->end())
- ++next_it;
-
- typename cntnr::iterator next_ers_it =
- m_p_c->erase(found_it);
-
- if (native_it != m_native_c.end())
- m_native_c.erase(native_it);
-
- bool range_guarantee =
- __gnu_pbds::detail::is_same<
- typename container_traits::invalidation_guarantee,
- __gnu_pbds::range_invalidation_guarantee>::value ;
-
- if (range_guarantee)
- PB_DS_THROW_IF_FAILED( next_ers_it == next_it, "", m_p_c, & m_native_c);
- }
- catch(__gnu_cxx::forced_exception_error& )
- {
- done = false;
-
- PB_DS_THROW_IF_FAILED( container_traits::erase_can_throw, container_traits::erase_can_throw, m_p_c, & m_native_c);
- }
-
- PB_DS_COND_COMPARE(*m_p_c, m_native_c);
-
- PB_DS_CANCEL_DESTRUCT_PRINT
-
- return (done);
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-erase_rev_it()
-{
- enum
- {
- erase_iterators =
- container_traits::order_preserving&&
- container_traits::reverse_iteration
- };
-
- return (erase_rev_it_imp(__gnu_pbds::detail::integral_constant<int,erase_iterators>()));
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-erase_rev_it_imp(__gnu_pbds::detail::false_type)
-{
- return (true);
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-erase_rev_it_imp(__gnu_pbds::detail::true_type)
-{
- PB_DS_TRACE("erase_rev_it");
-
- bool done = true;
-
- PB_DS_SET_DESTRUCT_PRINT
-
- try
- {
- m_alloc.set_throw_prob(0);
-
- const key_type k =
- test_traits::generate_key(m_g, m_m);
-
- m_alloc.set_throw_prob(m_tp);
-
- typename cntnr::iterator found_it = m_p_c->find(k);
-
- typename native_type::iterator native_it = m_native_c.find(
- test_traits::native_key(k));
-
- typename cntnr::const_reverse_iterator next_it = found_it;
- if (next_it != m_p_c->end())
- ++next_it;
-
- typename cntnr::reverse_iterator next_ers_it =
- m_p_c->erase((typename cntnr::reverse_iterator)found_it);
-
- PB_DS_THROW_IF_FAILED( next_ers_it == next_it, "", m_p_c, & m_native_c);
-
- if (native_it != m_native_c.end())
- m_native_c.erase(native_it);
- }
- catch(__gnu_cxx::forced_exception_error& )
- {
- done = false;
-
- PB_DS_THROW_IF_FAILED( container_traits::erase_can_throw, container_traits::erase_can_throw, m_p_c, & m_native_c);
- }
-
- PB_DS_COND_COMPARE(*m_p_c, m_native_c);
-
- PB_DS_CANCEL_DESTRUCT_PRINT
-
- return (done);
-}
-
+++ /dev/null
-// -*- C++ -*-
-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License as published by the Free Software
-// Foundation; either version 2, or (at your option) any later
-// version.
-
-// This library is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this library; see the file COPYING. If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-
-// As a special exception, you may use this file as part of a free
-// software library without restriction. Specifically, if other files
-// instantiate templates or use macros or inline functions from this
-// file, or you compile this file and link it with other files to
-// produce an executable, this file does not by itself cause the
-// resulting executable to be covered by the GNU General Public
-// License. This exception does not however invalidate any other
-// reasons why the executable file might be covered by the GNU General
-// Public License.
-
-// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
-
-// Permission to use, copy, modify, sell, and distribute this software
-// is hereby granted without fee, provided that the above copyright
-// notice appears in all copies, and that both that copyright notice
-// and this permission notice appear in supporting documentation. None
-// of the above authors, nor IBM Haifa Research Laboratories, make any
-// representation about the suitability of this software for any
-// purpose. It is provided "as is" without express or implied
-// warranty.
-
-/**
- * @file get_set_load_fn_imps.hpp
- * Containsert a random regression test for a specific container type.
- */
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-get_set_load()
-{
- typedef
- __gnu_pbds::detail::integral_constant<int,
- test_traits::get_set_load>
- get_set_load_ind;
-
- get_set_load_imp(get_set_load_ind());
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-get_set_load_imp(__gnu_pbds::detail::false_type)
-{ }
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-get_set_load_imp(__gnu_pbds::detail::true_type)
-{
- PB_DS_TRACE("get_set_load");
-
- PB_DS_SET_DESTRUCT_PRINT
-
- m_p_c->get_load();
-
- m_alloc.set_throw_prob(1);
-
- typename alloc_t::group_throw_prob_adjustor adjust(
- m_p_c->size());
-
- const float min_load = static_cast<float>(0.05);
- const float max_load = static_cast<float>(0.9);
-
- const float new_load =
- static_cast<float>(
- m_g.get_prob()* (max_load - min_load) +
- min_load);
-
- m_p_c->set_load(new_load);
-
- PB_DS_THROW_IF_FAILED(
- m_p_c->get_load() == new_load,
- "",
- m_p_c,
- & m_native_c);
-
- PB_DS_COND_COMPARE(*m_p_c, m_native_c);
-
- PB_DS_CANCEL_DESTRUCT_PRINT
- }
-
+++ /dev/null
-// -*- C++ -*-
-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License as published by the Free Software
-// Foundation; either version 2, or (at your option) any later
-// version.
-
-// This library is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this library; see the file COPYING. If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-
-// As a special exception, you may use this file as part of a free
-// software library without restriction. Specifically, if other files
-// instantiate templates or use macros or inline functions from this
-// file, or you compile this file and link it with other files to
-// produce an executable, this file does not by itself cause the
-// resulting executable to be covered by the GNU General Public
-// License. This exception does not however invalidate any other
-// reasons why the executable file might be covered by the GNU General
-// Public License.
-
-// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
-
-// Permission to use, copy, modify, sell, and distribute this software
-// is hereby granted without fee, provided that the above copyright
-// notice appears in all copies, and that both that copyright notice
-// and this permission notice appear in supporting documentation. None
-// of the above authors, nor IBM Haifa Research Laboratories, make any
-// representation about the suitability of this software for any
-// purpose. It is provided "as is" without express or implied
-// warranty.
-
-/**
- * @file get_set_loads_fn_imps.hpp
- * Containsert a random regression test for a specific container type.
- */
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-get_set_loads()
-{
- typedef
- __gnu_pbds::detail::integral_constant<int,
- test_traits::get_set_loads>
- get_set_loads_ind;
-
- return (get_set_loads_imp(get_set_loads_ind()));
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-get_set_loads_imp(__gnu_pbds::detail::false_type)
-{
- return (true);
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-get_set_loads_imp(__gnu_pbds::detail::true_type)
-{
- PB_DS_TRACE("get_set_loads");
-
- bool done = true;
-
- PB_DS_SET_DESTRUCT_PRINT
-
- const std::pair<float, float> old_loads =
- m_p_c->get_loads();
-
- try
- {
- m_alloc.set_throw_prob(m_tp);
-
- typename alloc_t::group_throw_prob_adjustor adjust(
- m_p_c->size());
-
- const float min_min_load = static_cast<float>(0.05);
- const float max_min_load = static_cast<float>(0.2);
-
- const float new_min_load =
- static_cast<float>(
- m_g.get_prob()* (max_min_load - min_min_load) +
- min_min_load);
-
- const float new_max_load = static_cast<float>(new_min_load* 2.5);
-
- PB_DS_THROW_IF_FAILED( new_max_load < 1, new_max_load, m_p_c, & m_native_c);
-
- m_p_c->set_loads(
- std::make_pair( new_min_load, new_max_load));
- }
- catch(...)
- {
- PB_DS_THROW_IF_FAILED(
- old_loads == m_p_c->get_loads(),
- old_loads.first << " " << old_loads.second << " " <<
- m_p_c->get_loads().first << " " <<
- m_p_c->get_loads().second,
- m_p_c,
- & m_native_c);
-
- done = false;
- }
-
- PB_DS_COND_COMPARE(*m_p_c, m_native_c);
-
- PB_DS_CANCEL_DESTRUCT_PRINT
-
- return (done);
-}
+++ /dev/null
-// -*- C++ -*-
-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License as published by the Free Software
-// Foundation; either version 2, or (at your option) any later
-// version.
-
-// This library is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this library; see the file COPYING. If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-
-// As a special exception, you may use this file as part of a free
-// software library without restriction. Specifically, if other files
-// instantiate templates or use macros or inline functions from this
-// file, or you compile this file and link it with other files to
-// produce an executable, this file does not by itself cause the
-// resulting executable to be covered by the GNU General Public
-// License. This exception does not however invalidate any other
-// reasons why the executable file might be covered by the GNU General
-// Public License.
-
-// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
-
-// Permission to use, copy, modify, sell, and distribute this software
-// is hereby granted without fee, provided that the above copyright
-// notice appears in all copies, and that both that copyright notice
-// and this permission notice appear in supporting documentation. None
-// of the above authors, nor IBM Haifa Research Laboratories, make any
-// representation about the suitability of this software for any
-// purpose. It is provided "as is" without express or implied
-// warranty.
-
-/**
- * @file insert_fn_imps.hpp
- * Containsert a random regression test for a specific container type.
- */
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-insert()
-{
- PB_DS_TRACE("insert");
- bool done = true;
- PB_DS_SET_DESTRUCT_PRINT
- try
- {
- m_alloc.set_throw_prob(0);
- value_type v = test_traits::generate_value(m_g, m_m);
- m_alloc.set_throw_prob(m_tp);
- const_key_reference r_k = test_traits::extract_key(v);
- typename cntnr::const_point_iterator found_it = m_p_c->find(r_k);
- const bool existed = (found_it != m_p_c->end());
- const std::pair<typename cntnr::point_iterator, bool> ins_ret = m_p_c->insert(v);
-
- if (ins_ret.second)
- {
- PB_DS_THROW_IF_FAILED(!existed, "", m_p_c, &m_native_c);
- }
- else
- {
- PB_DS_THROW_IF_FAILED(existed, "", m_p_c, &m_native_c);
- PB_DS_THROW_IF_FAILED(found_it == ins_ret.first, "", m_p_c, &m_native_c);
- }
- m_native_c.insert(test_traits::native_value(v));
- }
- catch(__gnu_cxx::forced_exception_error&)
- {
- done = false;
- }
- catch(__gnu_pbds::insert_error&)
- {
- PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
- }
-
- PB_DS_COND_COMPARE(*m_p_c, m_native_c);
- PB_DS_CANCEL_DESTRUCT_PRINT
- return (done);
-}
-
+++ /dev/null
-// -*- C++ -*-
-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License as published by the Free Software
-// Foundation; either version 2, or (at your option) any later
-// version.
-
-// This library is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this library; see the file COPYING. If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-
-// As a special exception, you may use this file as part of a free
-// software library without restriction. Specifically, if other files
-// instantiate templates or use macros or inline functions from this
-// file, or you compile this file and link it with other files to
-// produce an executable, this file does not by itself cause the
-// resulting executable to be covered by the GNU General Public
-// License. This exception does not however invalidate any other
-// reasons why the executable file might be covered by the GNU General
-// Public License.
-
-// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
-
-// Permission to use, copy, modify, sell, and distribute this software
-// is hereby granted without fee, provided that the above copyright
-// notice appears in all copies, and that both that copyright notice
-// and this permission notice appear in supporting documentation. None
-// of the above authors, nor IBM Haifa Research Laboratories, make any
-// representation about the suitability of this software for any
-// purpose. It is provided "as is" without express or implied
-// warranty.
-
-/**
- * @file it_conversion_fn_imps.hpp
- * Containsert a random regression test for a specific container type.
- */
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-it_copy()
-{
- {
- typename cntnr::iterator it = m_p_c->end();
-
- typename cntnr::const_iterator const_it(it);
-
- PB_DS_THROW_IF_FAILED( const_it == it, "", m_p_c, & m_native_c);
-
- PB_DS_THROW_IF_FAILED(
- !(const_it != it),
- "",
- m_p_c,
- & m_native_c);
-
- typename cntnr::const_point_iterator const_find_it(it);
-
- PB_DS_THROW_IF_FAILED( const_find_it == it, "", m_p_c, & m_native_c);
-
- PB_DS_THROW_IF_FAILED(
- !(const_find_it != it),
- "",
- m_p_c,
- & m_native_c);
-
- typename cntnr::point_iterator find_it(it);
-
- PB_DS_THROW_IF_FAILED( find_it == it, "", m_p_c, & m_native_c);
-
- PB_DS_THROW_IF_FAILED(
- !(find_it != it),
- "",
- m_p_c,
- & m_native_c);
- }
-
- {
- typename cntnr::const_iterator const_it = m_p_c->end();
-
- typename cntnr::const_point_iterator const_find_it(const_it);
-
- PB_DS_THROW_IF_FAILED( const_find_it == const_it, "", m_p_c, & m_native_c);
-
- PB_DS_THROW_IF_FAILED(
- !(const_find_it != const_it),
- "",
- m_p_c,
- & m_native_c);
- }
-
- {
- typename cntnr::point_iterator find_it = m_p_c->end();
-
- typename cntnr::const_point_iterator const_find_it(find_it);
-
- PB_DS_THROW_IF_FAILED( find_it == const_find_it, "", m_p_c, & m_native_c);
-
- PB_DS_THROW_IF_FAILED(
- !(find_it != const_find_it),
- "",
- m_p_c,
- & m_native_c);
- }
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-it_assign()
-{
- {
- typename cntnr::iterator it = m_p_c->end();
-
- typename cntnr::const_iterator const_it;
- const_it = it;
-
- PB_DS_THROW_IF_FAILED( const_it == it, "", m_p_c, & m_native_c);
-
- PB_DS_THROW_IF_FAILED(
- !(const_it != it),
- "",
- m_p_c,
- & m_native_c);
-
- typename cntnr::const_point_iterator const_find_it;
- const_find_it = it;
-
- PB_DS_THROW_IF_FAILED( const_find_it == it, "", m_p_c, & m_native_c);
-
- PB_DS_THROW_IF_FAILED(
- !(const_find_it != it),
- "",
- m_p_c,
- & m_native_c);
-
- typename cntnr::point_iterator find_it;
- find_it = it;
-
- PB_DS_THROW_IF_FAILED( find_it == it, "", m_p_c, & m_native_c);
-
- PB_DS_THROW_IF_FAILED(
- !(find_it != it),
- "",
- m_p_c,
- & m_native_c);
- }
-
- {
- typename cntnr::const_iterator const_it = m_p_c->end();
-
- typename cntnr::const_point_iterator const_find_it;
- const_find_it = const_it;
-
- PB_DS_THROW_IF_FAILED( const_find_it == const_it, "", m_p_c, & m_native_c);
-
- PB_DS_THROW_IF_FAILED(
- !(const_find_it != const_it),
- "",
- m_p_c,
- & m_native_c);
- }
-
- {
- typename cntnr::point_iterator find_it = m_p_c->end();
-
- typename cntnr::const_point_iterator const_find_it;
- const_find_it = find_it;
-
- PB_DS_THROW_IF_FAILED( find_it == const_find_it, "", m_p_c, & m_native_c);
-
- PB_DS_THROW_IF_FAILED(
- !(find_it != const_find_it),
- "",
- m_p_c,
- & m_native_c);
- }
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-rev_it_copy()
-{
- enum
- {
- reverse_iteration = container_traits::reverse_iteration
- };
-
- rev_it_copy_imp(__gnu_pbds::detail::integral_constant<int,reverse_iteration>());
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-rev_it_assign()
-{
- enum
- {
- reverse_iteration = container_traits::reverse_iteration
- };
-
- rev_it_assign_imp(__gnu_pbds::detail::integral_constant<int,reverse_iteration>());
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-rev_it_copy_imp(__gnu_pbds::detail::false_type)
-{ }
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-rev_it_copy_imp(__gnu_pbds::detail::true_type)
-{
- {
- typename cntnr::iterator it = m_p_c->end();
-
- typename cntnr::const_reverse_iterator const_it(it);
-
- PB_DS_THROW_IF_FAILED( const_it == it, "", m_p_c, & m_native_c);
-
- PB_DS_THROW_IF_FAILED(
- !(const_it != it),
- "",
- m_p_c,
- & m_native_c);
-
- typename cntnr::const_point_iterator const_find_it(it);
-
- PB_DS_THROW_IF_FAILED( const_find_it == it, "", m_p_c, & m_native_c);
-
- PB_DS_THROW_IF_FAILED(
- !(const_find_it != it),
- "",
- m_p_c,
- & m_native_c);
-
- typename cntnr::point_iterator find_it(it);
-
- PB_DS_THROW_IF_FAILED( find_it == it, "", m_p_c, & m_native_c);
-
- PB_DS_THROW_IF_FAILED(
- !(find_it != it),
- "",
- m_p_c,
- & m_native_c);
- }
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-rev_it_assign_imp(__gnu_pbds::detail::false_type)
-{ }
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-rev_it_assign_imp(__gnu_pbds::detail::true_type)
-{
- {
- typename cntnr::iterator it = m_p_c->end();
-
- typename cntnr::const_reverse_iterator const_it;
- const_it = it;
-
- PB_DS_THROW_IF_FAILED( const_it == it, "", m_p_c, & m_native_c);
-
- PB_DS_THROW_IF_FAILED(
- !(const_it != it),
- "",
- m_p_c,
- & m_native_c);
-
- typename cntnr::const_point_iterator const_find_it;
- const_find_it = it;
-
- PB_DS_THROW_IF_FAILED( const_find_it == it, "", m_p_c, & m_native_c);
-
- PB_DS_THROW_IF_FAILED(
- !(const_find_it != it),
- "",
- m_p_c,
- & m_native_c);
-
- typename cntnr::point_iterator find_it;
- find_it = it;
-
- PB_DS_THROW_IF_FAILED( find_it == it, "", m_p_c, & m_native_c);
-
- PB_DS_THROW_IF_FAILED(
- !(find_it != it),
- "",
- m_p_c,
- & m_native_c);
- }
-}
+++ /dev/null
-// -*- C++ -*-
-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License as published by the Free Software
-// Foundation; either version 2, or (at your option) any later
-// version.
-
-// This library is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this library; see the file COPYING. If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-
-// As a special exception, you may use this file as part of a free
-// software library without restriction. Specifically, if other files
-// instantiate templates or use macros or inline functions from this
-// file, or you compile this file and link it with other files to
-// produce an executable, this file does not by itself cause the
-// resulting executable to be covered by the GNU General Public
-// License. This exception does not however invalidate any other
-// reasons why the executable file might be covered by the GNU General
-// Public License.
-
-// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
-
-// Permission to use, copy, modify, sell, and distribute this software
-// is hereby granted without fee, provided that the above copyright
-// notice appears in all copies, and that both that copyright notice
-// and this permission notice appear in supporting documentation. None
-// of the above authors, nor IBM Haifa Research Laboratories, make any
-// representation about the suitability of this software for any
-// purpose. It is provided "as is" without express or implied
-// warranty.
-
-/**
- * @file operator_fn_imps.hpp
- * Contains a random regression test for a specific container type.
- */
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-operator()()
-{
- typedef xml_result_set_regression_formatter formatter_type;
- formatter_type* p_fmt = NULL;
-
- if (m_disp)
- p_fmt = new formatter_type(string_form<Cntnr>::name(),
- string_form<Cntnr>::desc());
-
- m_g.init(m_seed);
-
- // Track allocation from this point only.
- const size_t memory_label = 775;
- m_alloc.init(m_seed);
- m_alloc.set_label(memory_label);
-
- prog_bar pb(m_n, std::cout, m_disp);
- m_i = 0;
-
- try
- {
- for (m_i = 0; m_i < m_n; ++m_i)
- {
- PB_DS_TRACE("Op #" << static_cast<unsigned long>(m_i));
- allocator_type::set_label(m_i);
- switch (m_i)
- {
- case 0:
- PB_DS_RUN_MTHD(default_constructor);
- break;
- case 1:
- defs();
- break;
- case 2:
- policy_access();
- break;
- case 3:
- it_copy();
- break;
- case 4:
- it_assign();
- break;
- case 5:
- rev_it_copy();
- break;
- case 6:
- rev_it_assign();
- break;
- default:
- switch(get_next_op())
- {
- case insert_op:
- switch(get_next_sub_op(2))
- {
- case 0:
- PB_DS_RUN_MTHD(insert)
- break;
- case 1:
- PB_DS_RUN_MTHD(subscript)
- break;
- default:
- PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
- }
- break;
- case erase_op:
- switch(get_next_sub_op(4))
- {
- case 0:
- PB_DS_RUN_MTHD(erase)
- break;
- case 1:
- PB_DS_RUN_MTHD(erase_if)
- break;
- case 2:
- PB_DS_RUN_MTHD(erase_it)
- break;
- case 3:
- PB_DS_RUN_MTHD(erase_rev_it)
- break;
- default:
- PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
- }
- break;
- case clear_op:
- PB_DS_RUN_MTHD(clear)
- break;
- case other_op:
- switch(get_next_sub_op(8))
- {
- case 0:
- swap();
- break;
- case 1:
- PB_DS_RUN_MTHD(copy_constructor)
- break;
- case 2:
- PB_DS_RUN_MTHD(it_constructor)
- break;
- case 3:
- PB_DS_RUN_MTHD(assignment_operator)
- break;
- case 4:
- PB_DS_RUN_MTHD(split_join)
- break;
- case 5:
- resize();
- break;
- case 6:
- get_set_load();
- break;
- case 7:
- get_set_loads();
- break;
- default:
- PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
- }
- break;
- default:
- PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
- };
- }
-
- pb.inc();
- }
- }
- catch (...)
- {
- std::cerr << "Failed at index " << static_cast<unsigned long>(m_i)
- << std::endl;
- delete m_p_c;
- throw;
- }
-
- // Clean up, then check for allocation by special label, set above.
- delete m_p_c;
-
- try
- { m_alloc.check_allocated(memory_label); }
- catch (...)
- {
- std::cerr << "detected leaks!" << std::endl;
- std::cerr << m_alloc << std::endl;
- PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
- }
-
- // Reset throw probability.
- m_alloc.set_throw_prob(0);
-
- if (m_disp)
- {
- std::cout << std::endl;
- delete p_fmt;
- }
-}
-
-PB_DS_CLASS_T_DEC
-typename PB_DS_CLASS_C_DEC::op
-PB_DS_CLASS_C_DEC::
-get_next_op()
-{
- const double prob = m_g.get_prob();
-
- if (prob < m_ip)
- return insert_op;
-
- if (prob < m_ip + m_ep)
- return erase_op;
-
- if (prob < m_ip + m_ep + m_cp)
- return clear_op;
-
- PB_DS_THROW_IF_FAILED(prob <= 1, prob, m_p_c, &m_native_c);
-
- return other_op;
-}
-
-PB_DS_CLASS_T_DEC
-size_t
-PB_DS_CLASS_C_DEC::
-get_next_sub_op(size_t max)
-{
- const double p = m_g.get_prob();
- const double delta = 1 / static_cast<double>(max);
- size_t i = 0;
- while (true)
- if (p <= (i + 1) * delta)
- {
- PB_DS_THROW_IF_FAILED(i < max,
- static_cast<unsigned long>(i) << " " <<
- static_cast<unsigned long>(max),
- m_p_c, &m_native_c);
-
- return i;
- }
- else
- ++i;
-}
+++ /dev/null
-// -*- C++ -*-
-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License as published by the Free Software
-// Foundation; either version 2, or (at your option) any later
-// version.
-
-// This library is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this library; see the file COPYING. If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-
-// As a special exception, you may use this file as part of a free
-// software library without restriction. Specifically, if other files
-// instantiate templates or use macros or inline functions from this
-// file, or you compile this file and link it with other files to
-// produce an executable, this file does not by itself cause the
-// resulting executable to be covered by the GNU General Public
-// License. This exception does not however invalidate any other
-// reasons why the executable file might be covered by the GNU General
-// Public License.
-
-// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
-
-// Permission to use, copy, modify, sell, and distribute this software
-// is hereby granted without fee, provided that the above copyright
-// notice appears in all copies, and that both that copyright notice
-// and this permission notice appear in supporting documentation. None
-// of the above authors, nor IBM Haifa Research Laboratories, make any
-// representation about the suitability of this software for any
-// purpose. It is provided "as is" without express or implied
-// warranty.
-
-/**
- * @file policy_access_fn_imps.hpp
- * Containsert a random regression test for a specific container type.
- */
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-policy_access()
-{
- policy_access(typename Cntnr::container_category());
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-policy_access(__gnu_pbds::basic_hash_tag)
-{
- {
- typename Cntnr::hash_fn& r_t =
- m_p_c->get_hash_fn();
-
- assert(&r_t != NULL);
- }
- {
- const typename Cntnr::hash_fn& r_t =((const Cntnr& )*m_p_c).get_hash_fn();
-
- assert(&r_t != NULL);
- }
-
- {
- typename Cntnr::eq_fn& r_t =
- m_p_c->get_eq_fn();
-
- assert(&r_t != NULL);
- }
- {
- const typename Cntnr::eq_fn& r_t =((const Cntnr& )*m_p_c).get_eq_fn();
-
- assert(&r_t != NULL);
- }
-
- {
- typename Cntnr::resize_policy& r_t =
- m_p_c->get_resize_policy();
-
- assert(&r_t != NULL);
- }
- {
- const typename Cntnr::resize_policy& r_t =((const Cntnr& )*m_p_c).get_resize_policy();
-
- assert(&r_t != NULL);
- }
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-policy_access(__gnu_pbds::cc_hash_tag)
-{
- policy_access(__gnu_pbds::basic_hash_tag());
-
- {
- typename Cntnr::comb_hash_fn& r_t =
- m_p_c->get_comb_hash_fn();
-
- assert(&r_t != NULL);
- }
- {
- const typename Cntnr::comb_hash_fn& r_t =((const Cntnr& )*m_p_c).get_comb_hash_fn();
-
- assert(&r_t != NULL);
- }
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-policy_access(__gnu_pbds::gp_hash_tag)
-{
- policy_access(__gnu_pbds::basic_hash_tag());
-
- {
- typename Cntnr::comb_probe_fn& r_t =
- m_p_c->get_comb_probe_fn();
-
- assert(&r_t != NULL);
- }
- {
- const typename Cntnr::comb_probe_fn& r_t =((const Cntnr& )*m_p_c).get_comb_probe_fn();
-
- assert(&r_t != NULL);
- }
-
- {
- typename Cntnr::probe_fn& r_t =
- m_p_c->get_probe_fn();
-
- assert(&r_t != NULL);
- }
- {
- const typename Cntnr::probe_fn& r_t =((const Cntnr& )*m_p_c).get_probe_fn();
-
- assert(&r_t != NULL);
- }
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-policy_access(__gnu_pbds::tree_tag)
-{
- {
- typename Cntnr::cmp_fn& r_t =
- m_p_c->get_cmp_fn();
-
- assert(&r_t != NULL);
- }
-
- {
- const typename Cntnr::cmp_fn& r_t =((const Cntnr& )*m_p_c).get_cmp_fn();
-
- assert(&r_t != NULL);
- }
-}
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-policy_access(__gnu_pbds::list_update_tag)
-{ }
-
-PB_DS_CLASS_T_DEC
-void
-PB_DS_CLASS_C_DEC::
-policy_access(__gnu_pbds::pat_trie_tag)
-{
- typename Cntnr::e_access_traits& r_t =
- m_p_c->get_e_access_traits();
-
- assert(&r_t != NULL);
-}
-
+++ /dev/null
-// -*- C++ -*-
-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License as published by the Free Software
-// Foundation; either version 2, or (at your option) any later
-// version.
-
-// This library is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this library; see the file COPYING. If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-
-// As a special exception, you may use this file as part of a free
-// software library without restriction. Specifically, if other files
-// instantiate templates or use macros or inline functions from this
-// file, or you compile this file and link it with other files to
-// produce an executable, this file does not by itself cause the
-// resulting executable to be covered by the GNU General Public
-// License. This exception does not however invalidate any other
-// reasons why the executable file might be covered by the GNU General
-// Public License.
-
-// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
-
-// Permission to use, copy, modify, sell, and distribute this software
-// is hereby granted without fee, provided that the above copyright
-// notice appears in all copies, and that both that copyright notice
-// and this permission notice appear in supporting documentation. None
-// of the above authors, nor IBM Haifa Research Laboratories, make any
-// representation about the suitability of this software for any
-// purpose. It is provided "as is" without express or implied
-// warranty.
-
-/**
- * @file resize_fn_imps.hpp
- * Containsert a random regression test for a specific container type.
- */
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-resize()
-{
- typedef __gnu_pbds::detail::integral_constant<int, test_traits::resize> resize_ind;
-
- return (resize_imp(resize_ind()));
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-resize_imp(__gnu_pbds::detail::false_type)
-{
- return (true);
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-resize_imp(__gnu_pbds::detail::true_type)
-{
- PB_DS_TRACE("resize");
-
- bool done = true;
-
- PB_DS_SET_DESTRUCT_PRINT
-
- const size_t old_size =
- m_p_c->get_actual_size();
-
- try
- {
- m_alloc.set_throw_prob(m_tp);
-
- typename alloc_t::group_throw_prob_adjustor
- adjust(m_p_c->size());
-
- enum
- {
- min_new_size = 200,
- max_new_size = 2000
- };
-
- const size_t new_size =
- m_g.get_unsigned_long(min_new_size, max_new_size);
-
- m_p_c->resize(new_size);
-
- const size_t actual_new_size =
- m_p_c->get_actual_size();
-
- PB_DS_THROW_IF_FAILED(
- actual_new_size >= new_size,
- static_cast<unsigned long>(actual_new_size) << " " <<
- static_cast<unsigned long>(new_size),
- m_p_c,
- & m_native_c);
- }
- catch(...)
- {
- PB_DS_THROW_IF_FAILED(
- m_p_c->get_actual_size() == old_size,
- static_cast<unsigned long>(m_p_c->get_actual_size()) <<
- " " << static_cast<unsigned long>(old_size),
- m_p_c,
- & m_native_c);
-
- done = false;
- }
-
- PB_DS_COND_COMPARE(*m_p_c, m_native_c);
-
- PB_DS_CANCEL_DESTRUCT_PRINT
-
- return (done);
-}
-
+++ /dev/null
-// -*- C++ -*-
-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License as published by the Free Software
-// Foundation; either version 2, or (at your option) any later
-// version.
-
-// This library is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this library; see the file COPYING. If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-
-// As a special exception, you may use this file as part of a free
-// software library without restriction. Specifically, if other files
-// instantiate templates or use macros or inline functions from this
-// file, or you compile this file and link it with other files to
-// produce an executable, this file does not by itself cause the
-// resulting executable to be covered by the GNU General Public
-// License. This exception does not however invalidate any other
-// reasons why the executable file might be covered by the GNU General
-// Public License.
-
-// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
-
-// Permission to use, copy, modify, sell, and distribute this software
-// is hereby granted without fee, provided that the above copyright
-// notice appears in all copies, and that both that copyright notice
-// and this permission notice appear in supporting documentation. None
-// of the above authors, nor IBM Haifa Research Laboratories, make any
-// representation about the suitability of this software for any
-// purpose. It is provided "as is" without express or implied
-// warranty.
-
-/**
- * @file split_join_fn_imps.hpp
- * Containsert a random regression test for a specific container type.
- */
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-split_join()
-{
- enum
- {
- split_join = container_traits::order_preserving
- };
-
- return (split_join_imp(__gnu_pbds::detail::integral_constant<int,split_join>()));
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-split_join_imp(__gnu_pbds::detail::false_type)
-{
- return (true);
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-split_join_imp(__gnu_pbds::detail::true_type)
-{
- PB_DS_TRACE("split_join");
-
- bool done = true;
-
- PB_DS_SET_DESTRUCT_PRINT
-
- try
- {
- m_alloc.set_throw_prob(0);
-
- Cntnr lhs(*m_p_c);
-
- Cntnr rhs;
-
- native_type native_lhs(m_native_c);
-
- native_type native_rhs;
-
- const key_type k =
- test_traits::generate_key(m_g, m_m);
-
- m_alloc.set_throw_prob(m_tp);
-
- lhs.split(k, rhs);
-
- typename native_type::const_iterator it =
- native_lhs.upper_bound(test_traits::native_key(k));
-
- while (!native_lhs.empty()&& it != native_lhs.end())
- {
- native_rhs.insert(*it);
-
- typename native_type::const_iterator next_it = it;
- ++next_it;
-
- native_lhs.erase(test_traits::extract_native_key(*it));
-
- it = next_it;
- }
-
- PB_DS_COND_COMPARE(lhs, native_lhs);
- PB_DS_COND_COMPARE(rhs, native_rhs);
-
- m_alloc.set_throw_prob(m_tp);
-
- if (m_g.get_prob() < 0.5)
- lhs.swap(rhs);
-
- lhs.join(rhs);
-
- PB_DS_THROW_IF_FAILED(
- rhs.size() == 0,
- static_cast<unsigned long>(rhs.size()),
- m_p_c,
- & m_native_c);
-
- PB_DS_THROW_IF_FAILED(
- rhs.empty(),
- static_cast<unsigned long>(rhs.size()),
- m_p_c,
- & m_native_c);
-
- m_p_c->swap(lhs);
- }
- catch(__gnu_cxx::forced_exception_error& )
- {
- done = false;
-
- PB_DS_THROW_IF_FAILED( container_traits::split_join_can_throw, container_traits::split_join_can_throw, m_p_c, & m_native_c);
- }
-
- PB_DS_COND_COMPARE(*m_p_c, m_native_c);
-
- PB_DS_CANCEL_DESTRUCT_PRINT
-
- return (done);
-}
+++ /dev/null
-// -*- C++ -*-
-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License as published by the Free Software
-// Foundation; either version 2, or (at your option) any later
-// version.
-
-// This library is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this library; see the file COPYING. If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-
-// As a special exception, you may use this file as part of a free
-// software library without restriction. Specifically, if other files
-// instantiate templates or use macros or inline functions from this
-// file, or you compile this file and link it with other files to
-// produce an executable, this file does not by itself cause the
-// resulting executable to be covered by the GNU General Public
-// License. This exception does not however invalidate any other
-// reasons why the executable file might be covered by the GNU General
-// Public License.
-
-// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
-
-// Permission to use, copy, modify, sell, and distribute this software
-// is hereby granted without fee, provided that the above copyright
-// notice appears in all copies, and that both that copyright notice
-// and this permission notice appear in supporting documentation. None
-// of the above authors, nor IBM Haifa Research Laboratories, make any
-// representation about the suitability of this software for any
-// purpose. It is provided "as is" without express or implied
-// warranty.
-
-/**
- * @file subscript_fn_imps.hpp
- * Containsert a random regression test for a specific container type.
- */
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-subscript()
-{
- PB_DS_TRACE("subscript");
-
- enum
- {
- no_data = __gnu_pbds::detail::is_same<
- typename Cntnr::const_key_reference,
- typename Cntnr::const_reference>::value
- };
-
- return (subscript_imp(__gnu_pbds::detail::integral_constant<int,no_data>()));
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-subscript_imp(__gnu_pbds::detail::false_type)
-{
- bool done = true;
-
- PB_DS_SET_DESTRUCT_PRINT
-
- try
- {
- m_alloc.set_throw_prob(0);
-
- value_type v = test_traits::generate_value(m_g, m_m);
-
- m_alloc.set_throw_prob(m_tp);
- (*m_p_c)[v.first] = v.second;
-
- m_native_c[test_traits::native_value(v).first] =
- test_traits::native_value(v).second;
- }
- catch(__gnu_cxx::forced_exception_error& )
- {
- done = false;
- }
-
- PB_DS_COND_COMPARE(*m_p_c, m_native_c);
-
- PB_DS_CANCEL_DESTRUCT_PRINT
-
- return (done);
-}
-
-PB_DS_CLASS_T_DEC
-bool
-PB_DS_CLASS_C_DEC::
-subscript_imp(__gnu_pbds::detail::true_type)
-{
- bool done = true;
-
- PB_DS_SET_DESTRUCT_PRINT
-
- try
- {
- m_alloc.set_throw_prob(0);
-
- value_type v = test_traits::generate_value(m_g, m_m);
-
- m_alloc.set_throw_prob(m_tp);
- (*m_p_c)[v] = __gnu_pbds::null_mapped_type();
-
- m_native_c.insert(test_traits::native_value(v));
- }
- catch(__gnu_cxx::forced_exception_error& )
- {
- done = false;
- }
-
- PB_DS_COND_COMPARE(*m_p_c, m_native_c);
-
- PB_DS_CANCEL_DESTRUCT_PRINT
-
- return (done);
-}
#include <iostream>
#include <vector>
-#include <regression/rand/assoc/container_rand_regression_test.hpp>
+#include <regression/rand/assoc/container_rand_regression_test.h>
#include <io/verified_cmd_line_input.hpp>
#include <common_type/assoc/common_type.hpp>
#include <regression/basic_type.hpp>
-#include <regression/assoc/common_type.hpp>
+#include <regression/common_type.hpp>
namespace __gnu_pbds
{
// Sane defaults.
size_t n = iter;
size_t m = keys;
- size_t sd = 0; // 0 = time-determined arbitrary
+ size_t sd = twister_rand_gen::get_time_determined_seed();
double tp = 0.2;
double ip = 0.6;
double ep = 0.2;
return -2;
};
+ // XXX RAII, constructor takes bool for display
xml_test_rand_regression_formatter* p_fmt = NULL;
- if (sd == 0)
- sd = twister_rand_gen::get_time_determined_seed();
if (disp)
- p_fmt = new xml_test_rand_regression_formatter(sd, n, m, tp, ip,
- ep, cp, mp);
+ p_fmt = new xml_test_rand_regression_formatter(sd, n, m, tp, ip, ep, cp, mp);
try
{
cerr << "* Performs the same operation on an cntnr object" << endl;
cerr << "* Possibly compares the container to the cntnr object" << endl;
cerr << "* Checks that exceptions (thrown by an allocator) "
- "do not violate exception guarantees";
+ "do not violate exception guarantees";
cerr << endl << endl;
- cerr << "sd = seed for random-number generator; 0 = "
- "time determined value" << endl;
+ cerr << "sd = seed for random-number generator; "
+ "0 = time determined value" << endl;
cerr << "n = number of iterations" << endl;
cerr << "m = number of distinct values" << endl;
cerr << "tp = probability that an exception will be actively thrown" << endl;
+++ /dev/null
-// -*- C++ -*-
-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License as published by the Free Software
-// Foundation; either version 2, or (at your option) any later
-// version.
-
-// This library is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this library; see the file COPYING. If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-
-// As a special exception, you may use this file as part of a free
-// software library without restriction. Specifically, if other files
-// instantiate templates or use macros or inline functions from this
-// file, or you compile this file and link it with other files to
-// produce an executable, this file does not by itself cause the
-// resulting executable to be covered by the GNU General Public
-// License. This exception does not however invalidate any other
-// reasons why the executable file might be covered by the GNU General
-// Public License.
-
-// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
-
-// Permission to use, copy, modify, sell, and distribute this software
-// is hereby granted without fee, provided that the above copyright
-// notice appears in all copies, and that both that copyright notice
-// and this permission notice appear in supporting documentation. None
-// of the above authors, nor IBM Haifa Research Laboratories, make any
-// representation about the suitability of this software for any
-// purpose. It is provided "as is" without express or implied
-// warranty.
-
-/**
- * @file xml_formatter.hpp
- * Contains an XML formatter for regression tests.
- */
-
-#ifndef PB_DS_XML_TEST_REGRESSION_FORMATTER_HPP
-#define PB_DS_XML_TEST_REGRESSION_FORMATTER_HPP
-
-#include <regression/rand/io/xml_formatter.hpp>
-
-namespace __gnu_pbds
-{
-
- namespace test
- {
-
- class xml_test_rand_regression_formatter : public xml_test_formatter
- {
- public:
- xml_test_rand_regression_formatter(size_t sd, size_t n, size_t m, double tp, double ip, double ep, double cp, double mp);
- };
-
- xml_test_rand_regression_formatter::
- xml_test_rand_regression_formatter(size_t sd, size_t n, size_t m, double tp, double ip, double ep, double cp, double mp)
- {
- std::cout << make_xml_tag("sd", "value", sd);
- std::cout << make_xml_tag("n", "value", n);
- std::cout << make_xml_tag("m", "value", m);
- std::cout << make_xml_tag("tp", "value", tp);
- std::cout << make_xml_tag("ip", "value", ip);
- std::cout << make_xml_tag("ep", "value", ep);
- std::cout << make_xml_tag("cp", "value", cp);
- std::cout << make_xml_tag("mp", "value", mp);
- }
-
- } // namespace test
-
-} // namespace __gnu_pbds
-
-#endif // #ifndef PB_DS_XML_TEST_REGRESSION_FORMATTER_HPP
+++ /dev/null
-// -*- C++ -*-
-
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
-//
-// This file is part of the GNU ISO C++ Library. This library is free
-// software; you can redistribute it and/or modify it under the terms
-// of the GNU General Public License as published by the Free Software
-// Foundation; either version 2, or (at your option) any later
-// version.
-
-// This library is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this library; see the file COPYING. If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-// MA 02111-1307, USA.
-
-// As a special exception, you may use this file as part of a free
-// software library without restriction. Specifically, if other files
-// instantiate templates or use macros or inline functions from this
-// file, or you compile this file and link it with other files to
-// produce an executable, this file does not by itself cause the
-// resulting executable to be covered by the GNU General Public
-// License. This exception does not however invalidate any other
-// reasons why the executable file might be covered by the GNU General
-// Public License.
-
-// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
-
-// Permission to use, copy, modify, sell, and distribute this software
-// is hereby granted without fee, provided that the above copyright
-// notice appears in all copies, and that both that copyright notice
-// and this permission notice appear in supporting documentation. None
-// of the above authors, nor IBM Haifa Research Laboratories, make any
-// representation about the suitability of this software for any
-// purpose. It is provided "as is" without express or implied
-// warranty.
-
-/**
- * @file xml_formatter.hpp
- * Contains an XML formatter for regression tests.
- */
-
-#ifndef PB_DS_XML_TEST_REGRESSION_FORMATTER_HPP
-#define PB_DS_XML_TEST_REGRESSION_FORMATTER_HPP
-
-#include <regression/rand/io/xml_formatter.hpp>
-
-namespace __gnu_pbds
-{
-
- namespace test
- {
-
- class xml_test_rand_regression_formatter : public xml_test_formatter
- {
- public:
- xml_test_rand_regression_formatter(size_t sd, size_t n, size_t m, double tp, double ip, double dp, double ep, double cp, double mp);
- };
-
- xml_test_rand_regression_formatter::
- xml_test_rand_regression_formatter(size_t sd, size_t n, size_t m, double tp, double ip, double dp, double ep, double cp, double mp)
- {
- std::cout << make_xml_tag("sd", "value", sd);
- std::cout << make_xml_tag("n", "value", n);
- std::cout << make_xml_tag("m", "value", m);
- std::cout << make_xml_tag("tp", "value", tp);
- std::cout << make_xml_tag("ip", "value", ip);
- std::cout << make_xml_tag("dp", "value", dp);
- std::cout << make_xml_tag("ep", "value", ep);
- std::cout << make_xml_tag("cp", "value", cp);
- std::cout << make_xml_tag("mp", "value", mp);
- }
-
- } // namespace test
-
-} // namespace __gnu_pbds
-
-#endif // #ifndef PB_DS_XML_TEST_REGRESSION_FORMATTER_HPP
--- /dev/null
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2008 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software
+// Foundation; either version 2, or (at your option) any later
+// version.
+
+// This library is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this library; see the file COPYING. If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+// MA 02111-1307, USA.
+
+// As a special exception, you may use this file as part of a free
+// software library without restriction. Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License. This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
+
+// Permission to use, copy, modify, sell, and distribute this software
+// is hereby granted without fee, provided that the above copyright
+// notice appears in all copies, and that both that copyright notice
+// and this permission notice appear in supporting documentation. None
+// of the above authors, nor IBM Haifa Research Laboratories, make any
+// representation about the suitability of this software for any
+// purpose. It is provided "as is" without express or implied
+// warranty.
+
+/**
+ * @file container_rand_regression_test.h
+ * Contains a random regression test for a specific container type.
+ */
+
+#ifndef PB_DS_CONTAINER_RAND_REGRESSION_TEST_H
+#define PB_DS_CONTAINER_RAND_REGRESSION_TEST_H
+
+#include <algorithm>
+#include <string>
+#include <sstream>
+#include <utility>
+#include <cassert>
+#include <regression/basic_type.hpp>
+#include <ext/pb_ds/priority_queue.hpp>
+#include <io/prog_bar.hpp>
+#include <testsuite_rng.h>
+#include <common_type/priority_queue/string_form.hpp>
+#include <regression/rand/xml_formatter.hpp>
+#include <regression/trait/priority_queue/trait.hpp>
+
+namespace __gnu_pbds
+{
+namespace test
+{
+namespace detail
+{
+ // Rand test specialized for a specific container.
+ template<typename Cntnr>
+ class container_rand_regression_test
+ {
+ private:
+ typedef Cntnr cntnr;
+ typedef typename cntnr::allocator_type allocator_type;
+ typedef typename cntnr::size_type size_type;
+ typedef twister_rand_gen gen;
+ typedef basic_type value_type;
+ typedef native_priority_queue<std::string, true> native_type;<
OSDN Git Service
