obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

110 files changed, 22055 insertions, 0 deletions

diff --git a/libstdc++-v3/testsuite/util/common_type/assoc/common_type.hpp b/libstdc++-v3/testsuite/util/common_type/assoc/common_type.hpp
new file mode 100644
index 000000000..562f418fa
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/common_type/assoc/common_type.hpp
@@ -0,0 +1,799 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 common types.
+ */
+
+#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>
+#include <ext/pb_ds/assoc_container.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    template<typename Key,
+	     typename Data,
+	     class Hash_Fn = typename __gnu_pbds::detail::default_hash_fn<Key>::type,
+	     class Eq_Fn = std::equal_to<Key>,
+	     class Allocator = std::allocator<std::pair<const Key, Data> > >
+    struct hash_common_types
+    {
+    private:
+      typedef typename Allocator::size_type size_type;
+
+      typedef
+      __gnu_pbds::test::hash_load_check_resize_trigger_t_<
+	Allocator,
+	1, 8,
+	1, 2,
+	false>
+      no_access_half_load_check_resize_trigger_policy;
+
+      typedef
+      __gnu_pbds::test::hash_load_check_resize_trigger_t_<
+	Allocator,
+	1, 8,
+	1, 2,
+	true>
+      access_half_load_check_resize_trigger_policy;
+
+      typedef
+      __gnu_pbds::test::hash_load_check_resize_trigger_t_<
+	Allocator,
+	1, 8,
+	1, 1,
+	false>
+      no_access_one_load_check_resize_trigger_policy;
+
+      typedef
+      __gnu_pbds::test::cc_hash_max_collision_check_resize_trigger_t_<
+	Allocator,
+	1, 2,
+	false>
+      no_access_half_max_col_check_check_resize_trigger_policy;
+
+      typedef
+      __gnu_pbds::test::cc_hash_max_collision_check_resize_trigger_t_<
+	Allocator,
+	1, 2,
+	true>
+      access_half_max_col_check_check_resize_trigger_policy;
+
+      typedef __gnu_pbds::test::linear_probe_fn_t_<Key, Allocator> lin_p_t;
+
+      typedef __gnu_pbds::test::quadratic_probe_fn_t_<Key, Allocator> quad_p_t;
+
+      typedef
+      typename __gnu_cxx::typelist::create4<
+	__gnu_pbds::detail::false_type,
+	__gnu_pbds::test::direct_mask_range_hashing_t_<
+	Allocator>,
+	no_access_half_load_check_resize_trigger_policy,
+	__gnu_pbds::test::hash_exponential_size_policy_t_<
+	Allocator> >::type
+      performance_cc_policy0;
+
+      typedef
+      typename __gnu_cxx::typelist::create4<
+	__gnu_pbds::detail::false_type,
+	__gnu_pbds::test::direct_mod_range_hashing_t_<
+	Allocator>,
+	no_access_half_load_check_resize_trigger_policy,
+	__gnu_pbds::test::hash_prime_size_policy_t_>::type
+      performance_cc_policy1;
+
+      typedef
+      typename __gnu_cxx::typelist::create4<
+	__gnu_pbds::detail::false_type,
+	__gnu_pbds::test::direct_mask_range_hashing_t_<
+	Allocator>,
+	no_access_one_load_check_resize_trigger_policy,
+	__gnu_pbds::test::hash_exponential_size_policy_t_<
+	Allocator> >::type
+      performance_cc_policy2;
+
+      typedef
+      typename __gnu_cxx::typelist::create4<
+	__gnu_pbds::detail::false_type,
+	__gnu_pbds::test::direct_mod_range_hashing_t_<
+	Allocator>,
+	no_access_one_load_check_resize_trigger_policy,
+	__gnu_pbds::test::hash_prime_size_policy_t_ >::type
+      performance_cc_policy3;
+
+      typedef
+      typename __gnu_cxx::typelist::create4<
+	__gnu_pbds::detail::true_type,
+	__gnu_pbds::test::direct_mask_range_hashing_t_<
+	Allocator>,
+	no_access_half_load_check_resize_trigger_policy,
+	__gnu_pbds::test::hash_exponential_size_policy_t_<
+	Allocator> >::type
+      performance_cc_policy4;
+
+      typedef
+      typename __gnu_cxx::typelist::create4<
+	__gnu_pbds::detail::false_type,
+	__gnu_pbds::test::direct_mask_range_hashing_t_<
+	Allocator>,
+	no_access_half_max_col_check_check_resize_trigger_policy,
+	__gnu_pbds::test::hash_exponential_size_policy_t_<
+	Allocator> >::type
+      performance_cc_policy5;
+
+      typedef
+      typename __gnu_cxx::typelist::create4<
+	__gnu_pbds::detail::false_type,
+	__gnu_pbds::test::direct_mask_range_hashing_t_<
+	Allocator>,
+	access_half_max_col_check_check_resize_trigger_policy,
+	__gnu_pbds::test::hash_exponential_size_policy_t_<
+	Allocator> >::type
+      regression_cc_policy0;
+
+      typedef
+      typename __gnu_cxx::typelist::create4<
+	__gnu_pbds::detail::false_type,
+	__gnu_pbds::test::direct_mask_range_hashing_t_<
+	Allocator>,
+	access_half_load_check_resize_trigger_policy,
+	__gnu_pbds::test::hash_exponential_size_policy_t_<
+	Allocator> >::type
+      regression_cc_policy1;
+
+      typedef
+      typename __gnu_cxx::typelist::create4<
+	__gnu_pbds::detail::true_type,
+	__gnu_pbds::test::direct_mod_range_hashing_t_<
+	Allocator>,
+	no_access_half_load_check_resize_trigger_policy,
+	__gnu_pbds::test::hash_prime_size_policy_t_ >::type
+      regression_cc_policy2;
+
+      typedef
+      typename __gnu_cxx::typelist::create5<
+	__gnu_pbds::detail::false_type,
+	lin_p_t,
+	__gnu_pbds::test::direct_mask_range_hashing_t_<
+	Allocator>,
+	no_access_half_load_check_resize_trigger_policy,
+	__gnu_pbds::test::hash_exponential_size_policy_t_<
+	Allocator> >::type
+      performance_gp_policy0;
+
+      typedef
+      typename __gnu_cxx::typelist::create5<
+	__gnu_pbds::detail::false_type,
+	quad_p_t,
+	__gnu_pbds::test::direct_mod_range_hashing_t_<
+	Allocator>,
+	no_access_half_load_check_resize_trigger_policy,
+	__gnu_pbds::test::hash_prime_size_policy_t_ >::type
+      performance_gp_policy1;
+
+      typedef
+      typename __gnu_cxx::typelist::create5<
+	__gnu_pbds::detail::false_type,
+	quad_p_t,
+	__gnu_pbds::test::direct_mod_range_hashing_t_<
+	Allocator>,
+	access_half_load_check_resize_trigger_policy,
+	__gnu_pbds::test::hash_prime_size_policy_t_>::type
+      regression_gp_policy0;
+
+      typedef
+      typename __gnu_cxx::typelist::create5<
+	__gnu_pbds::detail::true_type,
+	lin_p_t,
+	__gnu_pbds::test::direct_mask_range_hashing_t_<
+	Allocator>,
+	access_half_load_check_resize_trigger_policy,
+	__gnu_pbds::test::hash_exponential_size_policy_t_<
+	Allocator> >::type
+      regression_gp_policy1;
+
+      typedef
+      typename __gnu_cxx::typelist::create6<
+	performance_cc_policy0,
+	performance_cc_policy1,
+	performance_cc_policy2,
+	performance_cc_policy3,
+	performance_cc_policy4,
+	performance_cc_policy5>::type
+      performance_cc_range_hashing_policies;
+
+      typedef
+      typename __gnu_cxx::typelist::create3<
+	regression_cc_policy0,
+	regression_cc_policy1,
+	regression_cc_policy2>::type
+      regression_cc_range_hashing_policies;
+
+      typedef
+      typename __gnu_cxx::typelist::create2<
+	performance_gp_policy0,
+	performance_gp_policy1>::type
+      performance_gp_range_hashing_policies;
+
+      typedef
+      typename __gnu_cxx::typelist::create2<
+	regression_gp_policy0,
+	regression_gp_policy1>::type
+      regression_gp_range_hashing_policies;
+
+      template<typename Policy_Tl>
+      struct no_access_generic_cc_hash_table_t
+      {
+      private:
+        typedef
+	typename __gnu_cxx::typelist::at_index<
+	Policy_Tl, 0>::type
+	store_hash_indicator;
+
+        enum
+	  {
+            store_hash = store_hash_indicator::value
+	  };
+
+        typedef
+	typename __gnu_cxx::typelist::at_index<
+	  Policy_Tl, 1>::type
+	comb_hash_fn;
+
+        typedef
+	typename __gnu_cxx::typelist::at_index<
+	  Policy_Tl, 2>::type
+	trigger_policy;
+
+        typedef
+	typename __gnu_cxx::typelist::at_index<
+	  Policy_Tl, 3>::type
+	size_policy;
+
+      public:
+        typedef
+	__gnu_pbds::cc_hash_table<
+	Key,
+	Data,
+	Hash_Fn,
+	Eq_Fn,
+	comb_hash_fn,
+	__gnu_pbds::hash_standard_resize_policy<
+	size_policy,
+	trigger_policy,
+	false>,
+	store_hash,
+	Allocator>
+	type;
+      };
+
+      template<typename Policy_Tl>
+      struct access_generic_cc_hash_table_t
+      {
+      private:
+        typedef
+	typename __gnu_cxx::typelist::at_index<
+	Policy_Tl, 0>::type
+	store_hash_indicator;
+
+        enum
+	  {
+            store_hash = store_hash_indicator::value
+	  };
+
+        typedef
+	typename __gnu_cxx::typelist::at_index<
+	  Policy_Tl, 1>::type
+	comb_hash_fn;
+
+        typedef
+	typename __gnu_cxx::typelist::at_index<
+	  Policy_Tl, 2>::type
+	trigger_policy;
+
+        typedef
+	typename __gnu_cxx::typelist::at_index<
+	  Policy_Tl, 3>::type
+	size_policy;
+
+      public:
+        typedef
+	__gnu_pbds::cc_hash_table<
+	Key,
+	Data,
+	Hash_Fn,
+	Eq_Fn,
+	comb_hash_fn,
+	__gnu_pbds::hash_standard_resize_policy<
+	size_policy,
+	trigger_policy,
+	true>,
+	store_hash,
+	Allocator>
+	type;
+      };
+
+      template<typename Policy_Tl>
+      struct no_access_generic_gp_hash_table_t
+      {
+      private:
+        typedef
+	typename __gnu_cxx::typelist::at_index<
+	Policy_Tl, 0>::type
+	store_hash_indicator;
+
+        enum
+	  {
+            store_hash = store_hash_indicator::value
+	  };
+
+        typedef
+	typename __gnu_cxx::typelist::at_index<
+	  Policy_Tl, 1>::type
+	probe_fn;
+
+        typedef
+	typename __gnu_cxx::typelist::at_index<
+	  Policy_Tl, 2>::type
+	comb_probe_fn;
+
+        typedef
+	typename __gnu_cxx::typelist::at_index<
+	  Policy_Tl, 3>::type
+	trigger_policy;
+
+        typedef
+	typename __gnu_cxx::typelist::at_index<
+	  Policy_Tl, 4>::type
+	size_policy;
+
+      public:
+        typedef
+	__gnu_pbds::gp_hash_table<
+	Key,
+	Data,
+	Hash_Fn,
+	Eq_Fn,
+	comb_probe_fn,
+	probe_fn,
+	__gnu_pbds::hash_standard_resize_policy<
+	size_policy,
+	trigger_policy,
+	false>,
+	store_hash,
+	Allocator>
+	type;
+      };
+
+      template<typename Policy_Tl>
+      struct access_generic_gp_hash_table_t
+      {
+      private:
+        typedef
+	typename __gnu_cxx::typelist::at_index<
+	Policy_Tl, 0>::type
+	store_hash_indicator;
+
+        enum
+	  {
+            store_hash = store_hash_indicator::value
+	  };
+
+        typedef
+	typename __gnu_cxx::typelist::at_index<
+	  Policy_Tl, 1>::type
+	probe_fn;
+
+        typedef
+	typename __gnu_cxx::typelist::at_index<
+	  Policy_Tl, 2>::type
+	comb_probe_fn;
+
+        typedef
+	typename __gnu_cxx::typelist::at_index<
+	  Policy_Tl, 3>::type
+	trigger_policy;
+
+        typedef
+	typename __gnu_cxx::typelist::at_index<
+	  Policy_Tl, 4>::type
+	size_policy;
+
+      public:
+        typedef
+	__gnu_pbds::gp_hash_table<
+	Key,
+	Data,
+	Hash_Fn,
+	Eq_Fn,
+	comb_probe_fn,
+	probe_fn,
+	__gnu_pbds::hash_standard_resize_policy<
+	size_policy,
+	trigger_policy,
+	true>,
+	store_hash,
+	Allocator>
+	type;
+      };
+
+      typedef
+      typename __gnu_cxx::typelist::transform<
+	performance_cc_range_hashing_policies,
+	no_access_generic_cc_hash_table_t>::type
+      performance_cc_types;
+
+      typedef
+      typename __gnu_cxx::typelist::transform<
+	regression_cc_range_hashing_policies,
+	access_generic_cc_hash_table_t>::type
+      regression_cc_types;
+
+      typedef
+      typename __gnu_cxx::typelist::at_index<
+	performance_cc_types,
+	0>::type
+      performance_min_cc_type;
+
+      typedef
+      typename __gnu_cxx::typelist::transform<
+	performance_gp_range_hashing_policies,
+	no_access_generic_gp_hash_table_t>::type
+      performance_gp_types;
+
+      typedef
+      typename __gnu_cxx::typelist::transform<
+	regression_gp_range_hashing_policies,
+	access_generic_gp_hash_table_t>::type
+      regression_gp_types;
+
+      typedef
+      typename __gnu_cxx::typelist::at_index<
+	performance_gp_types,
+	0>::type
+      performance_min_gp_type;
+
+    public:
+      typedef
+      typename __gnu_cxx::typelist::append<
+      performance_cc_types,
+      performance_gp_types>::type
+      performance_tl;
+
+      typedef
+      typename __gnu_cxx::typelist::append<
+	regression_gp_types,
+	regression_cc_types>::type
+      regression_tl;
+
+      typedef
+      typename __gnu_cxx::typelist::create1<
+	performance_min_cc_type>::type
+      performance_min_tl;
+    };
+
+    template<typename Key,
+	     typename Data,
+	     class Comb_Hash_Fn_TL,
+	     class Comb_Probe_Fn_TL,
+	     class Eq_Fn =
+	     std::equal_to<Key>,
+	     class Allocator =
+	     std::allocator<
+      std::pair<
+      const Key,
+      Data> > >
+    struct ranged_hash_common_types
+    {
+    private:
+      typedef typename Allocator::size_type size_type;
+
+      typedef
+      __gnu_pbds::test::hash_load_check_resize_trigger_t_<
+	Allocator,
+	1, 8,
+	1, 2,
+	false>
+      no_access_half_load_check_resize_trigger_policy;
+
+      typedef
+      __gnu_pbds::test::hash_load_check_resize_trigger_t_<
+	Allocator,
+	1, 8,
+	1, 1,
+	false>
+      no_access_one_load_check_resize_trigger_policy;
+
+      typedef
+      __gnu_pbds::hash_standard_resize_policy<
+	__gnu_pbds::test::hash_exponential_size_policy_t_<
+	Allocator>,
+	no_access_half_load_check_resize_trigger_policy>
+      mask_half_resize_policy_t;
+
+      typedef
+      __gnu_pbds::hash_standard_resize_policy<
+	__gnu_pbds::test::hash_exponential_size_policy_t_<
+	Allocator>,
+	no_access_one_load_check_resize_trigger_policy>
+      mask_one_resize_policy_t;
+
+      typedef
+      __gnu_pbds::hash_standard_resize_policy<
+	__gnu_pbds::test::hash_prime_size_policy_t_,
+	no_access_half_load_check_resize_trigger_policy>
+      mod_half_resize_policy_t;
+
+      typedef
+      __gnu_pbds::hash_standard_resize_policy<
+	__gnu_pbds::test::hash_prime_size_policy_t_,
+	no_access_one_load_check_resize_trigger_policy>
+      mod_one_resize_policy_t;
+
+      template<typename Comb_Hash_Fn_>
+      struct half_resize_policy_selector;
+
+      template<typename Allocator_>
+      struct half_resize_policy_selector<
+        __gnu_pbds::test::direct_mask_range_hashing_t_<
+	Allocator_> >
+      {
+        typedef mask_half_resize_policy_t type;
+      };
+
+      template<typename Allocator_>
+      struct half_resize_policy_selector<
+        __gnu_pbds::test::direct_mod_range_hashing_t_<
+	Allocator_> >
+      {
+        typedef mod_half_resize_policy_t type;
+      };
+
+      template<typename Comb_Hash_Fn_>
+      struct one_resize_policy_selector;
+
+      template<typename Allocator_>
+      struct one_resize_policy_selector<
+        __gnu_pbds::test::direct_mask_range_hashing_t_<
+	Allocator_> >
+      {
+        typedef mask_one_resize_policy_t type;
+      };
+
+      template<typename Allocator_>
+      struct one_resize_policy_selector<
+        __gnu_pbds::test::direct_mod_range_hashing_t_<
+	Allocator_> >
+      {
+        typedef mod_one_resize_policy_t type;
+      };
+
+      template<typename Comb_Hash_Fn>
+      struct generic_cc_hash_table_t
+      {
+        typedef
+	__gnu_pbds::cc_hash_table<
+	  Key,
+	  Data,
+	  __gnu_pbds::null_hash_fn,
+	  Eq_Fn,
+	  Comb_Hash_Fn,
+	  typename one_resize_policy_selector<
+	  typename Comb_Hash_Fn::comb_fn>::type,
+	  false,
+	  Allocator>
+	type;
+      };
+
+      typedef
+      typename __gnu_cxx::typelist::transform<
+	Comb_Hash_Fn_TL,
+	generic_cc_hash_table_t>::type
+      performance_cc_types;
+
+      template<typename Comb_Probe_Fn>
+      struct no_access_generic_gp_hash_table_t
+      {
+        typedef
+	__gnu_pbds::gp_hash_table<
+	  Key,
+	  Data,
+	  __gnu_pbds::null_hash_fn,
+	  Eq_Fn,
+	  Comb_Probe_Fn,
+	  __gnu_pbds::null_probe_fn,
+	  typename half_resize_policy_selector<
+	  typename Comb_Probe_Fn::comb_fn>::type,
+	  false,
+	  Allocator>
+	type;
+      };
+
+      typedef
+      typename __gnu_cxx::typelist::transform<
+	Comb_Probe_Fn_TL,
+	no_access_generic_gp_hash_table_t>::type
+      performance_gp_types;
+
+    public:
+      typedef
+      typename __gnu_cxx::typelist::append<
+      performance_cc_types,
+      performance_gp_types>::type
+      performance_tl;
+    };
+
+    template<typename Key, typename Data, class Eq_Fn = std::equal_to<Key>,
+	     class Allocator =
+	     std::allocator<char> >
+    class lu_common_types
+    {
+    private:
+      typedef typename Allocator::size_type size_type;
+
+      typedef __gnu_pbds::test::move_to_front_lu_policy_t_ mtf_u;
+
+      typedef __gnu_pbds::test::counter_lu_policy_t_<Allocator, 5> cnt_5_u;
+
+      typedef typename __gnu_cxx::typelist::create1<mtf_u>::type lu_policy0;
+
+      typedef typename __gnu_cxx::typelist::create1<cnt_5_u>::type lu_policy1;
+
+      typedef
+      typename __gnu_cxx::typelist::create2<lu_policy0, lu_policy1>::type
+      lu_policies;
+
+      template<typename Policy_Tl>
+      struct generic_list_update_t
+      {
+      private:
+        typedef
+	typename __gnu_cxx::typelist::at_index<Policy_Tl, 0>::type
+	update_policy_t;
+
+      public:
+        typedef
+	__gnu_pbds::list_update<Key, Data, Eq_Fn, update_policy_t, Allocator>
+	type;
+      };
+
+      typedef
+      typename __gnu_cxx::typelist::transform<
+	lu_policies,
+	generic_list_update_t>::type
+      lu_types;
+
+      typedef
+      typename __gnu_cxx::typelist::at_index<
+	lu_types,
+	0>::type
+      min_lu_type;
+
+    public:
+      typedef lu_types performance_tl;
+      typedef lu_types regression_tl;
+
+      typedef typename __gnu_cxx::typelist::create1<min_lu_type>::type performance_min_tl;
+    };
+
+    template<typename Key, typename Data, class Cmp_Fn = std::less<Key>,
+	     template<typename Const_Node_Iterator,
+		      class Node_Iterator,
+		      class Cmp_Fn_,
+		      class Allocator_>
+    class Node_Update = __gnu_pbds::null_tree_node_update,
+	     class Allocator = std::allocator<std::pair<const Key, Data> > >
+    struct tree_common_types
+    {
+    private:
+      typedef
+      __gnu_pbds::tree<
+      Key,
+      Data,
+      Cmp_Fn,
+      __gnu_pbds::ov_tree_tag,
+      Node_Update,
+      Allocator>
+      ov_tree_assoc_container_t;
+
+      typedef
+      __gnu_pbds::tree<
+	Key,
+	Data,
+	Cmp_Fn,
+	__gnu_pbds::rb_tree_tag,
+	Node_Update,
+	Allocator>
+      rb_tree_assoc_container_t;
+
+      typedef
+      __gnu_pbds::tree<
+	Key,
+	Data,
+	Cmp_Fn,
+	__gnu_pbds::splay_tree_tag,
+	Node_Update,
+	Allocator>
+      splay_tree_assoc_container_t;
+
+    public:
+      typedef
+      typename __gnu_cxx::typelist::create3<
+      splay_tree_assoc_container_t,
+      rb_tree_assoc_container_t,
+      ov_tree_assoc_container_t>::type
+      performance_tl;
+
+      typedef
+      typename __gnu_cxx::typelist::create3<
+	ov_tree_assoc_container_t,
+	splay_tree_assoc_container_t,
+	rb_tree_assoc_container_t>::type
+      regression_tl;
+
+      typedef
+      typename __gnu_cxx::typelist::create1<
+	rb_tree_assoc_container_t>::type
+      performance_min_tl;
+    };
+
+    template<typename Key,
+	     typename Data,
+	     class E_Access_Traits =
+	     typename __gnu_pbds::detail::default_trie_e_access_traits<Key>::type,
+	     class Tag = __gnu_pbds::pat_trie_tag,
+	     template<typename Const_Node_Iterator,
+		      typename Node_Iterator,
+		      class E_Access_Traits_,
+		      typename Allocator_>
+    class Node_Update = __gnu_pbds::null_trie_node_update,
+	     class Allocator = std::allocator<char> >
+    class trie_common_types
+    {
+    private:
+      typedef __gnu_pbds::trie<Key, Data, E_Access_Traits, Tag, Node_Update, Allocator> type;
+
+    public:
+      typedef typename __gnu_cxx::typelist::create1<type>::type performance_tl;
+      typedef typename __gnu_cxx::typelist::create1<type>::type regression_tl;
+      typedef typename __gnu_cxx::typelist::create1<type>::type performance_min_tl;
+    };
+
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_COMMON_TYPES_ASSOC_HPP
diff --git a/libstdc++-v3/testsuite/util/common_type/assoc/detail/comb_hash_fn_string_form.hpp b/libstdc++-v3/testsuite/util/common_type/assoc/detail/comb_hash_fn_string_form.hpp
new file mode 100644
index 000000000..0410ec977
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/common_type/assoc/detail/comb_hash_fn_string_form.hpp
@@ -0,0 +1,98 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 comb_hash_fn_string_form.hpp
+ * Transforms containers into string form.
+ */
+
+#ifndef PB_DS_COMB_HASH_FN_STRING_FORM_HPP
+#define PB_DS_COMB_HASH_FN_STRING_FORM_HPP
+
+#include <string>
+#include <common_type/assoc/template_policy.hpp>
+#include <io/xml.hpp>
+
+namespace __gnu_pbds
+{
+namespace test
+{
+namespace detail
+{
+
+  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
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_COMB_HASH_FN_STRING_FORM_HPP
+
diff --git a/libstdc++-v3/testsuite/util/common_type/assoc/detail/ds_string_form.hpp b/libstdc++-v3/testsuite/util/common_type/assoc/detail/ds_string_form.hpp
new file mode 100644
index 000000000..9ee5c4dd7
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/common_type/assoc/detail/ds_string_form.hpp
@@ -0,0 +1,255 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 ds_string_form.hpp
+ * Transforms containers into string form.
+ */
+
+#ifndef PB_DS_DS_STRING_FORM_HPP
+#define PB_DS_DS_STRING_FORM_HPP
+
+#include <string>
+#include <ext/pb_ds/tag_and_trait.hpp>
+#include <common_type/assoc/detail/list_update_policy_string_form.hpp>
+#include <common_type/assoc/detail/comb_hash_fn_string_form.hpp>
+#include <common_type/assoc/detail/resize_policy_string_form.hpp>
+#include <common_type/assoc/detail/probe_fn_string_form.hpp>
+#include <common_type/assoc/detail/tree_supports_order_statistics.hpp>
+#include <common_type/assoc/detail/trie_supports_order_statistics.hpp>
+#include <common_type/assoc/detail/trie_supports_prefix_search.hpp>
+#include <common_type/assoc/detail/store_hash_string_form.hpp>
+#include <io/xml.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>
+      {
+	static std::string
+        name()
+	{
+	  return ("cc_hash_" +
+		  comb_hash_fn_string_form<typename Cntnr::comb_hash_fn>::name() +
+		  resize_policy_string_form<typename Cntnr::resize_policy>::name() +
+		  store_hash_string_form<Cntnr::store_hash>::name());
+	}
+
+	static std::string
+        desc()
+	{
+	  const std::string comb_hash_fn_desc =
+            comb_hash_fn_string_form<typename Cntnr::comb_hash_fn>::desc();
+
+	  const std::string resize_policy_desc =
+            resize_policy_string_form<typename Cntnr::resize_policy>::desc();
+
+	  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));
+	}
+      };
+
+      template<typename Cntnr>
+      struct ds_string_form<Cntnr, __gnu_pbds::gp_hash_tag>
+      {
+	static std::string
+        name()
+	{
+	  return ("gp_hash_" +
+		  comb_hash_fn_string_form<typename Cntnr::comb_probe_fn>::name() +
+		  probe_fn_string_form<typename Cntnr::probe_fn>::name() +
+		  resize_policy_string_form<typename Cntnr::resize_policy>::name() +
+		  store_hash_string_form<Cntnr::store_hash>::name());
+	}
+
+	static std::string
+        desc()
+	{
+	  const std::string comb_probe_fn_desc =
+            comb_hash_fn_string_form<typename Cntnr::comb_probe_fn>::desc();
+
+	  const std::string probe_fn_desc =
+            probe_fn_string_form<typename Cntnr::probe_fn>::desc();
+
+	  const std::string resize_policy_desc =
+            resize_policy_string_form<typename Cntnr::resize_policy>::desc();
+
+	  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);
+	}
+      };
+
+      template<typename Cntnr>
+      struct tree_ds_string_form
+      {
+	static std::string
+        name(const std::string container_category_str)
+	{
+	  if (tree_supports_order_statistics<Cntnr>::value)
+            return (container_category_str + "ost_");
+	  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);
+
+	  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"));
+
+	  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>
+      {
+      private:
+	typedef tree_ds_string_form< Cntnr> base_type;
+
+      public:
+	static std::string
+        name()
+	{ return base_type::name("rb_tree_"); }
+
+	static std::string
+        desc()
+	{ 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>
+      {
+      private:
+	typedef tree_ds_string_form< Cntnr> base_type;
+
+      public:
+	static std::string
+        name()
+	{ return base_type::name("splay_tree_"); }
+
+	static std::string
+        desc()
+	{ 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>
+      {
+      private:
+	typedef tree_ds_string_form< Cntnr> base_type;
+
+      public:
+	static std::string
+        name()
+	{ return (base_type::name("ov_tree_")); }
+
+	static std::string
+        desc()
+	{ return (base_type::desc("ov_tree_tag")); }
+      };
+
+      template<typename Cntnr>
+      struct ds_string_form<Cntnr, __gnu_pbds::list_update_tag>
+      {
+	static std::string
+        name()
+	{
+	  return ("lu_" +
+		  lu_policy_string_form<typename Cntnr::update_policy>::name());
+	}
+
+	static std::string
+        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>
+      {
+	static std::string
+        name()
+	{
+	  if (trie_supports_order_statistics<Cntnr>::value)
+            return ("pat_trie_ost_");
+
+	  if (trie_supports_prefix_search<Cntnr>::value)
+            return ("pat_trie_prs_");
+
+	  return ("pat_trie_");
+	}
+
+	static std::string
+        desc()
+	{
+	  std::string category_s = make_xml_tag("Tag", "value", "pat_trie_tag");
+	  const char* s;
+	  if (trie_supports_order_statistics<Cntnr>::value)
+            s = "trie_order_statistics_node_update";
+	  else if (trie_supports_prefix_search<Cntnr>::value)
+	    s = "trie_prefix_search_node_update";
+	  else
+            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);
+	}
+      };
+
+    } // namespace detail
+
+  } // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_DS_STRING_FORM_HPP
+
diff --git a/libstdc++-v3/testsuite/util/common_type/assoc/detail/list_update_policy_string_form.hpp b/libstdc++-v3/testsuite/util/common_type/assoc/detail/list_update_policy_string_form.hpp
new file mode 100644
index 000000000..ed3747fa1
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/common_type/assoc/detail/list_update_policy_string_form.hpp
@@ -0,0 +1,97 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 lu_policy_string_form.hpp
+ * Transforms containers into string form.
+ */
+
+#ifndef PB_DS_LU_POLICY_STRING_FORM_HPP
+#define PB_DS_LU_POLICY_STRING_FORM_HPP
+
+#include <string>
+#include <common_type/assoc/template_policy.hpp>
+#include <io/xml.hpp>
+
+namespace __gnu_pbds
+{
+
+  namespace test
+  {
+
+    namespace detail
+    {
+
+      template<typename Update_Policy>
+      struct lu_policy_string_form;
+
+      template<>
+      struct lu_policy_string_form<move_to_front_lu_policy_t_>
+      {
+	static std::string
+        name()
+	{ return ("mtf_"); }
+
+	static std::string
+        desc()
+	{
+	  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> >
+      {
+	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));
+	}
+      };
+
+    } // namespace detail
+
+  } // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_LU_POLICY_STRING_FORM_HPP
+
diff --git a/libstdc++-v3/testsuite/util/common_type/assoc/detail/probe_fn_string_form.hpp b/libstdc++-v3/testsuite/util/common_type/assoc/detail/probe_fn_string_form.hpp
new file mode 100644
index 000000000..15cbbfda5
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/common_type/assoc/detail/probe_fn_string_form.hpp
@@ -0,0 +1,99 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 probe_fn_string_form.hpp
+ * Transforms containers into string form.
+ */
+
+#ifndef PB_DS_PROBE_FN_STRING_FORM_HPP
+#define PB_DS_PROBE_FN_STRING_FORM_HPP
+
+#include <string>
+#include <common_type/assoc/template_policy.hpp>
+#include <io/xml.hpp>
+
+namespace __gnu_pbds
+{
+
+  namespace test
+  {
+
+    namespace detail
+    {
+
+      template<typename Probe_Fn>
+      struct probe_fn_string_form;
+
+      template<typename Key, class Allocator>
+      struct probe_fn_string_form<linear_probe_fn_t_<Key, Allocator> >
+      {
+	static std::string
+        name()
+	{ return ("linp_"); }
+
+	static std::string
+        desc()
+	{ 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> >
+      {
+	static std::string
+        name()
+	{ return ("quadp_"); }
+
+	static std::string
+        desc()
+	{ return make_xml_tag("Probe_Fn", "value", "quadratic_probe_fn"); }
+      };
+
+      template<>
+      struct probe_fn_string_form<__gnu_pbds::null_probe_fn>
+      {
+	static std::string
+        name()
+	{ return (""); }
+
+	static std::string
+        desc()
+	{ return make_xml_tag("Probe_Fn", "value", "null_probe_fn"); }
+      };
+
+    } // namespace detail
+
+  } // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_PROBE_FN_STRING_FORM_HPP
+
diff --git a/libstdc++-v3/testsuite/util/common_type/assoc/detail/resize_policy_string_form.hpp b/libstdc++-v3/testsuite/util/common_type/assoc/detail/resize_policy_string_form.hpp
new file mode 100644
index 000000000..8d5b68698
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/common_type/assoc/detail/resize_policy_string_form.hpp
@@ -0,0 +1,93 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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_policy_string_form.hpp
+ * Transforms containers into string form.
+ */
+
+#ifndef PB_DS_RESIZE_POLICY_STRING_FORM_HPP
+#define PB_DS_RESIZE_POLICY_STRING_FORM_HPP
+
+#include <string>
+#include <common_type/assoc/detail/size_policy_string_form.hpp>
+#include <common_type/assoc/detail/trigger_policy_string_form.hpp>
+#include <common_type/assoc/template_policy.hpp>
+#include <io/xml.hpp>
+
+namespace __gnu_pbds
+{
+
+  namespace test
+  {
+
+    namespace detail
+    {
+
+      template<typename Resize_Policy>
+      struct resize_policy_string_form;
+
+      template<typename Size_Policy,
+	       class Trigger_Policy,
+	       bool External_Size_Access,
+	       typename Size_Type>
+      struct resize_policy_string_form<
+	__gnu_pbds::hash_standard_resize_policy<
+        Size_Policy, Trigger_Policy, External_Size_Access, Size_Type> >
+      {
+	static std::string
+        name()
+	{
+	  return (size_policy_string_form<Size_Policy>::name() +
+		  trigger_policy_string_form<Trigger_Policy>::name());
+	}
+
+	static std::string
+        desc()
+	{
+	  const std::string size_policy_string_form_desc =
+            size_policy_string_form<Size_Policy>::desc();
+
+	  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));
+	}
+      };
+
+    } // namespace detail
+
+  } // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_RESIZE_POLICY_STRING_FORM_HPP
+
diff --git a/libstdc++-v3/testsuite/util/common_type/assoc/detail/size_policy_string_form.hpp b/libstdc++-v3/testsuite/util/common_type/assoc/detail/size_policy_string_form.hpp
new file mode 100644
index 000000000..d2b61facb
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/common_type/assoc/detail/size_policy_string_form.hpp
@@ -0,0 +1,95 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 size_policy_string_form.hpp
+ * Transforms containers into string form.
+ */
+
+#ifndef PB_DS_SIZE_POLICY_STRING_FORM_HPP
+#define PB_DS_SIZE_POLICY_STRING_FORM_HPP
+
+#include <string>
+#include <common_type/assoc/detail/size_policy_string_form.hpp>
+#include <common_type/assoc/detail/trigger_policy_string_form.hpp>
+#include <common_type/assoc/template_policy.hpp>
+#include <io/xml.hpp>
+
+namespace __gnu_pbds
+{
+
+  namespace test
+  {
+
+    namespace detail
+    {
+
+      template<typename Size_Policy>
+      struct size_policy_string_form;
+
+      template<typename Allocator>
+      struct size_policy_string_form<
+	__gnu_pbds::test::hash_exponential_size_policy_t_<Allocator> >
+      {
+	static std::string
+        name()
+	{ return ("exp_"); }
+
+	static std::string
+        desc()
+	{
+	  return (make_xml_tag("Size_Policy", "value", "hash_exponential_size_policy"));
+	}
+      };
+
+      template<>
+      struct size_policy_string_form<
+	__gnu_pbds::test::hash_prime_size_policy_t_>
+      {
+	static std::string
+        name()
+	{ return ("prime_"); }
+
+	static std::string
+        desc()
+	{
+	  return (make_xml_tag("Size_Policy", "value", "hash_prime_size_policy"));
+	}
+      };
+
+    } // namespace detail
+
+  } // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_SIZE_POLICY_STRING_FORM_HPP
+
diff --git a/libstdc++-v3/testsuite/util/common_type/assoc/detail/store_hash_string_form.hpp b/libstdc++-v3/testsuite/util/common_type/assoc/detail/store_hash_string_form.hpp
new file mode 100644
index 000000000..a932948fa
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/common_type/assoc/detail/store_hash_string_form.hpp
@@ -0,0 +1,82 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 store_hash_string_form.hpp
+ * Transforms containers into string form.
+ */
+
+#ifndef PB_DS_STORE_HASH_STRING_FORM_HPP
+#define PB_DS_STORE_HASH_STRING_FORM_HPP
+
+#include <string>
+#include <common_type/assoc/template_policy.hpp>
+#include <io/xml.hpp>
+
+namespace __gnu_pbds
+{
+
+  namespace test
+  {
+
+    namespace detail
+    {
+
+      template<bool Store_Hash>
+      struct store_hash_string_form
+      {
+	static std::string
+        name()
+	{ return ("sth_"); }
+
+	static std::string
+        desc()
+	{ return (make_xml_tag("Store_Hash", "value", "true")); }
+      };
+
+      template<>
+      struct store_hash_string_form<false>
+      {
+	static std::string
+	name()
+        { return ("nsth_"); }
+
+	static std::string
+        desc()
+        { return (make_xml_tag("Store_Hash",  "value",  "false")); }
+      };
+
+    } // namespace detail
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_STORE_HASH_STRING_FORM_HPP
+
diff --git a/libstdc++-v3/testsuite/util/common_type/assoc/detail/tree_supports_order_statistics.hpp b/libstdc++-v3/testsuite/util/common_type/assoc/detail/tree_supports_order_statistics.hpp
new file mode 100644
index 000000000..80c1abe54
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/common_type/assoc/detail/tree_supports_order_statistics.hpp
@@ -0,0 +1,73 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 tree_supports_order_statistics.hpp
+ * Checks whether a tree supports order statistics.
+ */
+
+#ifndef PB_DS_TREE_SUPPORTS_ORDER_STATISTICS_HPP
+#define PB_DS_TREE_SUPPORTS_ORDER_STATISTICS_HPP
+
+#include <ext/pb_ds/tree_policy.hpp>
+
+namespace __gnu_pbds
+{
+
+  namespace test
+  {
+
+    namespace detail
+    {
+
+      template<typename Tree_Cntnr>
+      struct tree_supports_order_statistics
+      {
+	enum
+	  {
+	    value = __gnu_pbds::detail::is_same<
+            typename Tree_Cntnr::node_update,
+            __gnu_pbds::tree_order_statistics_node_update<
+            typename Tree_Cntnr::const_node_iterator,
+            typename Tree_Cntnr::node_iterator,
+            typename Tree_Cntnr::cmp_fn,
+            typename Tree_Cntnr::allocator_type> >::value
+	  };
+      };
+
+    } // namespace detail
+
+  } // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_TREE_SUPPORTS_ORDER_STATISTICS_HPP
+
diff --git a/libstdc++-v3/testsuite/util/common_type/assoc/detail/trie_supports_order_statistics.hpp b/libstdc++-v3/testsuite/util/common_type/assoc/detail/trie_supports_order_statistics.hpp
new file mode 100644
index 000000000..fc9cacc63
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/common_type/assoc/detail/trie_supports_order_statistics.hpp
@@ -0,0 +1,73 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 trie_supports_order_statistics.hpp
+ * Checks whether a trie supports order stats.
+ */
+
+#ifndef PB_DS_TRIE_SUPPORTS_ORDER_STATISTICS_HPP
+#define PB_DS_TRIE_SUPPORTS_ORDER_STATISTICS_HPP
+
+#include <ext/pb_ds/trie_policy.hpp>
+
+namespace __gnu_pbds
+{
+
+  namespace test
+  {
+
+    namespace detail
+    {
+
+      template<typename Tree_Cntnr>
+      struct trie_supports_order_statistics
+      {
+	enum
+	  {
+	    value = __gnu_pbds::detail::is_same<
+            typename Tree_Cntnr::node_update,
+            __gnu_pbds::trie_order_statistics_node_update<
+            typename Tree_Cntnr::const_node_iterator,
+            typename Tree_Cntnr::node_iterator,
+            typename Tree_Cntnr::e_access_traits,
+            typename Tree_Cntnr::allocator_type> >::value
+	  };
+      };
+
+    } // namespace detail
+
+  } // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_TRIE_SUPPORTS_ORDER_STATISTICS_HPP
+
diff --git a/libstdc++-v3/testsuite/util/common_type/assoc/detail/trie_supports_prefix_search.hpp b/libstdc++-v3/testsuite/util/common_type/assoc/detail/trie_supports_prefix_search.hpp
new file mode 100644
index 000000000..20c521010
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/common_type/assoc/detail/trie_supports_prefix_search.hpp
@@ -0,0 +1,73 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 trie_supports_prefix_search.hpp
+ * Checks whether a trie supports prefix search.
+ */
+
+#ifndef PB_DS_TRIE_SUPPORTS_PREFIX_SEARCH_HPP
+#define PB_DS_TRIE_SUPPORTS_PREFIX_SEARCH_HPP
+
+#include <ext/pb_ds/trie_policy.hpp>
+
+namespace __gnu_pbds
+{
+
+  namespace test
+  {
+
+    namespace detail
+    {
+
+      template<typename Tree_Cntnr>
+      struct trie_supports_prefix_search
+      {
+	enum
+	  {
+	    value = __gnu_pbds::detail::is_same<
+            typename Tree_Cntnr::node_update,
+            __gnu_pbds::trie_prefix_search_node_update<
+            typename Tree_Cntnr::const_node_iterator,
+            typename Tree_Cntnr::node_iterator,
+            typename Tree_Cntnr::e_access_traits,
+            typename Tree_Cntnr::allocator_type> >::value
+	  };
+      };
+
+    } // namespace detail
+
+  } // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_TRIE_SUPPORTS_PREFIX_SEARCH_HPP
+
diff --git a/libstdc++-v3/testsuite/util/common_type/assoc/detail/trigger_policy_string_form.hpp b/libstdc++-v3/testsuite/util/common_type/assoc/detail/trigger_policy_string_form.hpp
new file mode 100644
index 000000000..be4fe264f
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/common_type/assoc/detail/trigger_policy_string_form.hpp
@@ -0,0 +1,141 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 trigger_policy_string_form.hpp
+ * Transforms containers into string form.
+ */
+
+#ifndef PB_DS_TRIGGER_POLICY_STRING_FORM_HPP
+#define PB_DS_TRIGGER_POLICY_STRING_FORM_HPP
+
+#include <string>
+#include <common_type/assoc/template_policy.hpp>
+#include <io/xml.hpp>
+
+namespace __gnu_pbds
+{
+
+  namespace test
+  {
+
+    namespace detail
+    {
+
+      template<typename Trigger_Policy>
+      struct trigger_policy_string_form;
+
+      template<typename Allocator,
+	       typename Allocator::size_type Min_Load_Nom,
+	       typename Allocator::size_type Min_Load_Denom,
+	       typename Allocator::size_type Max_Load_Nom,
+	       typename Allocator::size_type Max_Load_Denom,
+	       bool External_Access>
+      struct trigger_policy_string_form<
+	__gnu_pbds::test::hash_load_check_resize_trigger_t_<
+        Allocator,
+        Min_Load_Nom,
+        Min_Load_Denom,
+        Max_Load_Nom,
+        Max_Load_Denom,
+        External_Access> >
+      {
+	static std::string
+        name()
+	{
+	  std::ostringstream ret;
+
+	  ret << (External_Access? "": "n") << "ea_"
+            "lc_" << Min_Load_Nom << "div" << Min_Load_Denom << "_" <<
+            Max_Load_Nom << "div" << Max_Load_Denom << "_";
+
+	  return (ret.str());
+	}
+
+	static std::string
+        desc()
+	{
+	  const std::string ext_access_desc =
+            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);
+
+	  return (make_xml_tag("Trigger_Policy", "value", "hash_load_check_resize_trigger", ext_access_desc + loads_desc));
+	}
+      };
+
+      template<typename Allocator,
+	       typename Allocator::size_type Load_Nom,
+	       typename Allocator::size_type Load_Denom,
+	       bool External_Access>
+      struct trigger_policy_string_form<
+	__gnu_pbds::test::cc_hash_max_collision_check_resize_trigger_t_<
+        Allocator,
+        Load_Nom,
+        Load_Denom,
+        External_Access> >
+      {
+	static std::string
+        name()
+	{
+	  std::ostringstream ret;
+
+	  ret << (External_Access? "": "n") << "ea_"
+            "mcolc_" << Load_Nom << "div" << Load_Denom << "_";
+
+	  return (ret.str());
+	}
+
+	static std::string
+        desc()
+	{
+	  const std::string ext_access_desc =
+            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);
+
+	  return (make_xml_tag("Trigger_Policy", "value", "cc_hash_max_collision_check_resize_trigger", ext_access_desc + load_desc));
+	}
+      };
+
+    } // namespace detail
+
+  } // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_TRIGGER_POLICY_STRING_FORM_HPP
+
diff --git a/libstdc++-v3/testsuite/util/common_type/assoc/native_set.hpp b/libstdc++-v3/testsuite/util/common_type/assoc/native_set.hpp
new file mode 100644
index 000000000..a2655fe75
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/common_type/assoc/native_set.hpp
@@ -0,0 +1,84 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 native_set.hpp
+ * Contains an adapter to Dinkumware/SGI tree tables
+ */
+
+#ifndef PB_DS_NATIVE_SET_HPP
+#define PB_DS_NATIVE_SET_HPP
+
+#include <ext/pb_ds/detail/standard_policies.hpp>
+#include <native_type/native_tree_tag.hpp>
+#include <io/xml.hpp>
+#include <string>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    template<typename Key, class Cmp_Fn = std::less<Key>,
+	     class Allocator = std::allocator<char> >
+    class native_set : public PB_DS_BASE_C_DEC
+    {
+    private:
+      typedef std::set<Key, Cmp_Fn, typename Allocator::template rebind<Key>::other> base_type;
+
+    public:
+      typedef native_tree_tag container_category;
+
+      typedef typename base_type::const_iterator const_iterator;
+
+    public:
+      native_set() : base_type()
+      { }
+
+      template<typename It>
+      native_set(It f,  It l) : base_type(f, l)
+      { }
+
+      native_set(const_iterator f,  const_iterator l) : base_type(f, l)
+      { }
+
+      static std::string
+      name()
+      { return ("n_set"); }
+
+      static std::string
+      desc()
+      { return (make_xml_tag("type", "value", "std_set")); }
+    };
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif
+
diff --git a/libstdc++-v3/testsuite/util/common_type/assoc/string_form.hpp b/libstdc++-v3/testsuite/util/common_type/assoc/string_form.hpp
new file mode 100644
index 000000000..d7825ac63
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/common_type/assoc/string_form.hpp
@@ -0,0 +1,179 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 string_form.hpp
+ * Transforms containers into string form.
+ */
+
+#ifndef PB_DS_STRING_FORM_HPP
+#define PB_DS_STRING_FORM_HPP
+
+#include <string>
+#include <sstream>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/tag_and_trait.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>
+#include <io/xml.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      template<typename Cntnr>
+      struct pb_ds_string_form
+      {
+      private:
+	typedef typename Cntnr::mapped_type mapped_type;
+
+	struct mapped_string_form
+	{
+	private:
+	  template<typename D_Cntnr>
+	  static std::string
+	  name(D_Cntnr)
+	  { return ("mmap_" + pb_ds_string_form<D_Cntnr>::name()); }
+
+	  template<typename D_Cntnr>
+	  static std::string
+	  desc(D_Cntnr)
+	  { return pb_ds_string_form<D_Cntnr>::desc(); }
+
+	  static std::string
+	  name(size_t)
+	  { return ("map"); }
+
+	  static std::string
+	  desc(size_t)
+	  { return (""); }
+
+	  static std::string
+	  name(basic_type)
+	  { return ("map"); }
+
+	  static std::string
+	  desc(basic_type)
+	  { return (""); }
+
+	  static std::string
+	  name(int)
+	  { return ("map"); }
+
+	  static std::string
+	  desc(int)
+	  { return (""); }
+
+	  static std::string
+	  name(char)
+	  { return ("map"); }
+
+	  static std::string
+	  desc(char)
+	  { return (""); }
+
+	  static std::string
+	  name(__gnu_pbds::null_mapped_type)
+	  { return ("set"); }
+
+	  static std::string
+	  desc(__gnu_pbds::null_mapped_type)
+	  { return (""); }
+
+	public:
+	  static std::string
+	  name()
+	  { return name(mapped_type()); }
+
+	  static std::string
+	  desc()
+	  { return desc(mapped_type()); }
+	};
+
+	typedef
+        detail::ds_string_form<Cntnr, typename Cntnr::container_category>
+        ds_string_form_t;
+
+      public:
+	static std::string
+        name()
+	{ return (ds_string_form_t::name() + mapped_string_form::name()); }
+
+	static std::string
+        desc()
+	{ return (ds_string_form_t::desc() + mapped_string_form::desc()); }
+      };
+
+      template<typename Cntnr>
+      struct native_string_form
+      {
+	static std::string
+        name()
+	{ return Cntnr::name(); }
+
+	static std::string
+        desc()
+	{ return Cntnr::desc(); }
+      };
+
+      template<typename Cntnr, class Tag>
+      struct tag_select_string_form : public pb_ds_string_form<Cntnr>
+      { };
+
+      template<typename Cntnr>
+      struct tag_select_string_form<Cntnr, native_hash_tag> 
+      : public native_string_form<Cntnr>
+      { };
+
+      template<typename Cntnr>
+      struct tag_select_string_form<Cntnr, native_tree_tag> 
+      : public native_string_form<Cntnr>
+      { };
+    } // namespace detail
+
+    template<typename Cntnr>
+    struct string_form 
+    : public detail::tag_select_string_form<Cntnr, 
+					    typename Cntnr::container_category>
+    { };
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif
+
diff --git a/libstdc++-v3/testsuite/util/common_type/assoc/template_policy.hpp b/libstdc++-v3/testsuite/util/common_type/assoc/template_policy.hpp
new file mode 100644
index 000000000..86db029e2
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/common_type/assoc/template_policy.hpp
@@ -0,0 +1,145 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 template_policy.hpp
+ * Contains template versions of policies.
+ */
+
+#ifndef PB_DS_TEMPLATE_POLICY_HPP
+#define PB_DS_TEMPLATE_POLICY_HPP
+
+#include <ext/typelist.h>
+#include <ext/pb_ds/hash_policy.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+#include <ext/pb_ds/list_update_policy.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    template<typename Allocator>
+    struct direct_mask_range_hashing_t_ 
+    : public __gnu_pbds::direct_mask_range_hashing<typename Allocator::size_type>
+    {
+      typedef typename Allocator::size_type size_type;
+      typedef __gnu_pbds::direct_mask_range_hashing<size_type> base_type;
+    };
+
+    template<typename Allocator>
+    struct direct_mod_range_hashing_t_ 
+    : public __gnu_pbds::direct_mod_range_hashing<typename Allocator::size_type>
+    {
+      typedef typename Allocator::size_type size_type;
+      typedef __gnu_pbds::direct_mod_range_hashing<size_type> base_type;
+    };
+
+    template<typename Allocator,
+	     typename Allocator::size_type Min_Load_Nom,
+	     typename Allocator::size_type Min_Load_Denom,
+	     typename Allocator::size_type Max_Load_Nom,
+	     typename Allocator::size_type Max_Load_Denom,
+	     bool External_Access>
+    struct hash_load_check_resize_trigger_t_ 
+    : public __gnu_pbds::hash_load_check_resize_trigger<External_Access,
+						   typename Allocator::size_type>
+    {
+      typedef typename Allocator::size_type size_type;
+      typedef __gnu_pbds::hash_load_check_resize_trigger<External_Access, size_type>  base_type;
+
+      inline
+      hash_load_check_resize_trigger_t_() 
+      : base_type(static_cast<float>(Min_Load_Nom) / static_cast<float>(Min_Load_Denom), static_cast<float>(Max_Load_Nom) / static_cast<float>(Max_Load_Denom))
+      { }
+
+      enum
+	{
+	  get_set_loads = External_Access,
+	  get_set_load = false
+	};
+    };
+
+    template<typename Allocator,
+	     typename Allocator::size_type Load_Nom,
+	     typename Allocator::size_type Load_Denom,
+	     bool External_Access>
+    struct cc_hash_max_collision_check_resize_trigger_t_ 
+    : public __gnu_pbds::cc_hash_max_collision_check_resize_trigger<External_Access,
+      typename Allocator::size_type>
+    {
+      typedef typename Allocator::size_type size_type;
+      typedef __gnu_pbds::cc_hash_max_collision_check_resize_trigger<External_Access, size_type> base_type;
+
+      inline
+      cc_hash_max_collision_check_resize_trigger_t_() 
+      : base_type(static_cast<float>(Load_Nom) / static_cast<float>(Load_Denom))
+      { }
+
+      enum
+	{
+	  get_set_load = External_Access,
+	  get_set_loads = false
+	};
+    };
+
+    struct hash_prime_size_policy_t_ : public __gnu_pbds::hash_prime_size_policy
+    { };
+
+    template<typename Allocator>
+    struct hash_exponential_size_policy_t_ 
+    : public __gnu_pbds::hash_exponential_size_policy<typename Allocator::size_type>
+    { };
+
+    template<typename Key, class Allocator>
+    struct linear_probe_fn_t_ 
+    : public __gnu_pbds::linear_probe_fn<typename Allocator::size_type>
+    { };
+
+    template<typename Key, class Allocator>
+    struct quadratic_probe_fn_t_ 
+    : public __gnu_pbds::quadratic_probe_fn<typename Allocator::size_type>
+    { };
+
+    template<typename Allocator, typename Allocator::size_type Max_Count>
+    struct counter_lu_policy_t_ 
+    : public __gnu_pbds::counter_lu_policy<Max_Count, Allocator>
+    {
+      typedef __gnu_pbds::counter_lu_policy<Max_Count, Allocator> base_type;
+    };
+
+    struct move_to_front_lu_policy_t_ 
+    : public __gnu_pbds::move_to_front_lu_policy<>
+    { };
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
+
diff --git a/libstdc++-v3/testsuite/util/common_type/priority_queue/common_type.hpp b/libstdc++-v3/testsuite/util/common_type/priority_queue/common_type.hpp
new file mode 100644
index 000000000..cc79b3eec
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/common_type/priority_queue/common_type.hpp
@@ -0,0 +1,75 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 common types.
+ */
+
+#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>
+#include <ext/typelist.h>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    template<typename Value_Type, typename Cmp_Fn = std::less<Value_Type>,
+	     class Allocator = std::allocator<Value_Type> >
+    struct pq_common_types
+    {
+    private:
+      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;
+
+      typedef __gnu_pbds::priority_queue<Value_Type, Cmp_Fn, __gnu_pbds::rc_binomial_heap_tag, Allocator> rc_binomial_heap_t;
+
+      typedef __gnu_pbds::priority_queue<Value_Type, Cmp_Fn, __gnu_pbds::binary_heap_tag, Allocator> binary_heap_t;
+
+      typedef __gnu_pbds::priority_queue<Value_Type, Cmp_Fn, __gnu_pbds::thin_heap_tag, Allocator> thin_heap_t;
+
+      typedef typename __gnu_cxx::typelist::create5<thin_heap_t, pairing_heap_t, binomial_heap_t, rc_binomial_heap_t, binary_heap_t>::type all_tl;
+
+    public:
+      typedef all_tl performance_tl;
+      typedef all_tl regression_tl;
+      typedef all_tl performance_min_tl;
+      typedef all_tl regression_min_tl;
+    };
+
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_COMMON_TYPES_PQ_HPP
diff --git a/libstdc++-v3/testsuite/util/common_type/priority_queue/detail/ds_string_form.hpp b/libstdc++-v3/testsuite/util/common_type/priority_queue/detail/ds_string_form.hpp
new file mode 100644
index 000000000..8194356b7
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/common_type/priority_queue/detail/ds_string_form.hpp
@@ -0,0 +1,130 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 ds_string_form.hpp
+ * Transforms containers into string form.
+ */
+
+#ifndef PB_DS_DS_STRING_FORM_HPP
+#define PB_DS_DS_STRING_FORM_HPP
+
+#include <string>
+#include <ext/pb_ds/tag_and_trait.hpp>
+#include <io/xml.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::pairing_heap_tag>
+      {
+	static std::string
+        name()
+	{ return "pairing_heap"; }
+
+	static std::string
+        desc()
+	{ return make_xml_tag("type", "value", "pairing_heap"); }
+      };
+
+      template<typename Cntnr>
+      struct ds_string_form<Cntnr, __gnu_pbds::thin_heap_tag>
+      {
+	static std::string
+        name()
+	{ return "thin_heap"; }
+
+	static std::string
+        desc()
+	{ return make_xml_tag("type", "value", "thin_heap"); }
+      };
+
+      template<typename Cntnr>
+      struct ds_string_form<Cntnr, __gnu_pbds::binomial_heap_tag>
+      {
+	static std::string
+        name()
+	{ return "binomial_heap"; }
+
+	static std::string
+        desc()
+	{ return make_xml_tag("type", "value", "binomial_heap"); }
+      };
+
+      template<typename Cntnr>
+      struct ds_string_form<Cntnr, __gnu_pbds::rc_binomial_heap_tag>
+      {
+	static std::string
+        name()
+	{ return "rc_binomial_heap"; }
+
+	static std::string
+        desc()
+	{ return make_xml_tag("type", "value", "rc_binomial_heap"); }
+      };
+
+      template<typename Cntnr>
+      struct ds_string_form<Cntnr, __gnu_pbds::binary_heap_tag>
+      {
+	static std::string
+        name()
+	{ return "binary_heap"; }
+
+	static std::string
+        desc()
+	{ 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
+
+#endif // #ifndef PB_DS_DS_STRING_FORM_HPP
+
diff --git a/libstdc++-v3/testsuite/util/common_type/priority_queue/string_form.hpp b/libstdc++-v3/testsuite/util/common_type/priority_queue/string_form.hpp
new file mode 100644
index 000000000..e3e13f87d
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/common_type/priority_queue/string_form.hpp
@@ -0,0 +1,99 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 string_form.hpp
+ * Transforms containers into string form.
+ */
+
+#ifndef PB_DS_STRING_FORM_HPP
+#define PB_DS_STRING_FORM_HPP
+
+#include <string>
+#include <sstream>
+#include <ext/pb_ds/detail/type_utils.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
+  {
+    namespace detail
+    {
+      template<typename Cntnr>
+      struct pb_ds_string_form
+      {
+      private:
+	typedef ds_string_form<Cntnr, typename Cntnr::container_category> ds_string_form_t;
+
+      public:
+	static std::string
+        name()
+	{ return ds_string_form_t::name(); }
+
+	static std::string
+        desc()
+	{ return ds_string_form_t::desc(); }
+      };
+
+      template<typename Cntnr>
+      struct native_string_form
+      {
+	static std::string
+        name()
+	{ return Cntnr::name(); }
+
+	static std::string
+        desc()
+	{ return Cntnr::desc(); }
+      };
+
+      template<typename Cntnr, class Tag>
+      struct tag_select_string_form : public pb_ds_string_form<Cntnr>
+      { };
+
+      template<typename Cntnr>
+      struct tag_select_string_form<Cntnr, native_pq_tag> 
+	: public native_string_form<Cntnr>
+      { };
+    } // namespace detail
+
+    template<typename Cntnr>
+    struct string_form 
+      : public detail::tag_select_string_form<Cntnr, typename Cntnr::container_category>
+    { };
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_STRING_FORM_HPP
+
diff --git a/libstdc++-v3/testsuite/util/debug/checks.h b/libstdc++-v3/testsuite/util/debug/checks.h
new file mode 100644
index 000000000..b42ef1a44
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/debug/checks.h
@@ -0,0 +1,379 @@
+// Copyright (C) 2010 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+//
+
+#include <vector>
+#include <deque>
+#include <list>
+#ifndef _GLIBCXX_DEBUG
+#  include <debug/vector>
+#  include <debug/deque>
+#  include <debug/list>
+#endif
+#include <testsuite_hooks.h>
+
+namespace __gnu_test
+{
+  template<typename _Tp>
+    struct CopyableValueType
+    {
+      typedef _Tp value_type;
+    };
+
+  template<typename _Tp1, typename _Tp2>
+    struct CopyableValueType<std::pair<const _Tp1, _Tp2> >
+    {
+      typedef std::pair<_Tp1, _Tp2> value_type;
+    };
+
+  template<typename _Tp>
+    struct generate_unique
+    {
+      typedef _Tp value_type;
+
+      operator value_type()
+      {
+	static value_type _S_;
+	++_S_;
+	return _S_;
+      }
+    };
+
+  template<typename _Tp1, typename _Tp2>
+    struct generate_unique<std::pair<_Tp1, _Tp2> >
+    {
+      typedef _Tp1 first_type;
+      typedef _Tp2 second_type;
+      typedef std::pair<_Tp1, _Tp2> pair_type;
+      
+      operator pair_type()
+      {
+	static first_type _S_1;
+	static second_type _S_2;
+	++_S_1;
+	++_S_2;
+	return pair_type(_S_1, _S_2);
+      }
+    };
+
+  // Check that invalid range of pointers is detected
+  template<typename _Tp>
+    void
+    check_assign1()
+    {
+      bool test __attribute__((unused)) = true;
+
+      typedef _Tp cont_type;
+      typedef typename cont_type::value_type cont_val_type;
+      typedef typename CopyableValueType<cont_val_type>::value_type val_type;
+      typedef std::vector<val_type> vector_type;
+
+      generate_unique<val_type> gu;
+
+      vector_type v;
+      for (int i = 0; i != 5; ++i)
+        v.push_back(gu);
+      VERIFY(v.size() == 5);
+
+      const val_type* first = &v.front() + 1;
+      const val_type* last = first + 2;
+
+      cont_type c1;
+      c1.assign(first, last);
+      VERIFY(c1.size() == 2);
+
+      cont_type c2;
+      c2.assign(last, first); // Expected failure
+    }
+
+  // Check that invalid range of debug random iterators is detected
+  template<typename _Tp>
+    void
+    check_assign2()
+    {
+      bool test __attribute__((unused)) = true;
+
+      typedef _Tp cont_type;
+      typedef typename cont_type::value_type cont_val_type;
+      typedef typename CopyableValueType<cont_val_type>::value_type val_type;
+      typedef std::vector<val_type> vector_type;
+
+      generate_unique<val_type> gu;
+
+      vector_type v;
+      for (int i = 0; i != 5; ++i)
+        v.push_back(gu);
+      VERIFY(v.size() == 5);
+
+      typename vector_type::iterator first = v.begin() + 1;
+      typename vector_type::iterator last = first + 2;
+      cont_type c1;
+      c1.assign(first, last);
+      VERIFY(c1.size() == 2);
+
+      cont_type c2;
+      c2.assign(last, first); // Expected failure
+    }
+
+  // Check that invalid range of debug !random debug iterators is detected
+  template<typename _Tp>
+    void
+    check_assign3()
+    {
+      bool test __attribute__((unused)) = true;
+
+      typedef _Tp cont_type;
+      typedef typename cont_type::value_type cont_val_type;
+      typedef typename CopyableValueType<cont_val_type>::value_type val_type;
+      typedef std::list<val_type> list_type;
+
+      generate_unique<val_type> gu;
+
+      list_type l;
+      for (int i = 0; i != 5; ++i)
+        l.push_back(gu);
+      VERIFY(l.size() == 5);
+
+      typename list_type::iterator first = l.begin(); ++first;
+      typename list_type::iterator last = first; ++last; ++last;
+      cont_type c1;
+      c1.assign(first, last);
+      VERIFY(c1.size() == 2);
+
+      cont_type c2;
+      c2.assign(last, first); // Expected failure
+    }
+
+  // Check that invalid range of pointers is detected
+  template<typename _Tp>
+    void
+    check_construct1()
+    {
+      bool test __attribute__((unused)) = true;
+
+      typedef _Tp cont_type;
+      typedef typename cont_type::value_type cont_val_type;
+      typedef typename CopyableValueType<cont_val_type>::value_type val_type;
+      typedef std::vector<val_type> vector_type;
+
+      generate_unique<val_type> gu;
+
+      vector_type v;
+      for (int i = 0; i != 5; ++i)
+        v.push_back(gu);
+      VERIFY(v.size() == 5);
+
+      val_type *first = &v.front() + 1;
+      val_type *last = first + 2;
+      cont_type c1(first, last);
+      VERIFY(c1.size() == 2);
+
+      cont_type c2(last, first); // Expected failure
+    } 
+
+  // Check that invalid range of debug random iterators is detected
+  template<typename _Tp>
+    void
+    check_construct2()
+    {
+      bool test __attribute__((unused)) = true;
+
+      typedef _Tp cont_type;
+      typedef typename cont_type::value_type cont_val_type;
+      typedef typename CopyableValueType<cont_val_type>::value_type val_type;
+      typedef std::vector<val_type> vector_type;
+
+      generate_unique<val_type> gu;
+
+      vector_type v;
+      for (int i = 0; i != 5; ++i)
+        v.push_back(gu);
+      VERIFY(v.size() == 5);
+
+      typename vector_type::iterator first = v.begin() + 1;
+      typename vector_type::iterator last = first + 2;
+      cont_type c1(first, last);
+      VERIFY(c1.size() == 2);
+
+      cont_type c2(last, first); // Expected failure
+    }
+
+  // Check that invalid range of debug not random iterators is detected
+  template<typename _Tp>
+    void
+    check_construct3()
+    {
+      bool test __attribute__((unused)) = true;
+
+      typedef _Tp cont_type;
+      typedef typename cont_type::value_type cont_val_type;
+      typedef typename CopyableValueType<cont_val_type>::value_type val_type;
+      typedef std::list<val_type> list_type;
+
+      generate_unique<val_type> gu;
+
+      list_type l;
+      for (int i = 0; i != 5; ++i)
+        l.push_back(gu);
+      VERIFY(l.size() == 5);
+
+      typename list_type::iterator first = l.begin(); ++first;
+      typename list_type::iterator last = first; ++last; ++last;
+      cont_type c1(first, last);
+      VERIFY(c1.size() == 2);
+
+      cont_type c2(last, first); // Expected failure
+    }
+
+  template <typename _Cont>
+    struct InsertRangeHelper
+    {
+      template <typename _It>
+        static void
+        Insert(_Cont& cont, _It first, _It last)
+	{ cont.insert(first, last); }
+    };
+
+  template <typename _Cont>
+    struct InsertRangeHelperAux
+    {
+      template <typename _It>
+        static void
+        Insert(_Cont& cont, _It first, _It last)
+	{ cont.insert(cont.begin(), first, last); }
+    };
+
+  template <typename _Tp1, typename _Tp2>
+    struct InsertRangeHelper<std::vector<_Tp1, _Tp2> >
+    : InsertRangeHelperAux<std::vector<_Tp1, _Tp2> >
+    { };
+
+  template <typename _Tp1, typename _Tp2>
+    struct InsertRangeHelper<std::deque<_Tp1, _Tp2> >
+    : InsertRangeHelperAux<std::deque<_Tp1, _Tp2> >
+    { };
+
+  template <typename _Tp1, typename _Tp2>
+    struct InsertRangeHelper<std::list<_Tp1, _Tp2> >
+    : InsertRangeHelperAux<std::list<_Tp1, _Tp2> >
+    { };
+
+#ifndef _GLIBCXX_DEBUG
+  template <typename _Tp1, typename _Tp2>
+    struct InsertRangeHelper<__gnu_debug::vector<_Tp1, _Tp2> >
+    : InsertRangeHelperAux<__gnu_debug::vector<_Tp1, _Tp2> >
+    { };
+
+  template <typename _Tp1, typename _Tp2>
+    struct InsertRangeHelper<__gnu_debug::deque<_Tp1, _Tp2> >
+    : InsertRangeHelperAux<__gnu_debug::deque<_Tp1, _Tp2> >
+    { };
+
+  template <typename _Tp1, typename _Tp2>
+    struct InsertRangeHelper<__gnu_debug::list<_Tp1, _Tp2> >
+    : InsertRangeHelperAux<__gnu_debug::list<_Tp1, _Tp2> >
+    { };
+#endif
+
+  template<typename _Tp>
+    void
+    check_insert1()
+    {
+      bool test __attribute__((unused)) = true;
+
+      typedef _Tp cont_type;
+      typedef typename cont_type::value_type cont_val_type;
+      typedef typename CopyableValueType<cont_val_type>::value_type val_type;
+      typedef std::vector<val_type> vector_type;
+
+      generate_unique<val_type> gu;
+
+      vector_type v;
+      for (int i = 0; i != 5; ++i)
+        v.push_back(gu);
+      VERIFY(v.size() == 5);
+
+      const val_type* first = &v.front() + 1;
+      const val_type* last = first + 2;
+
+      cont_type c1;
+      InsertRangeHelper<cont_type>::Insert(c1, first, last);
+      VERIFY(c1.size() == 2);
+
+      cont_type c2;
+      InsertRangeHelper<cont_type>::Insert(c2, last, first); // Expected failure
+    }
+
+  template<typename _Tp>
+    void
+    check_insert2()
+    {
+      bool test __attribute__((unused)) = true;
+
+      typedef _Tp cont_type;
+      typedef typename cont_type::value_type cont_val_type;
+      typedef typename CopyableValueType<cont_val_type>::value_type val_type;
+      typedef std::vector<val_type> vector_type;
+
+      generate_unique<val_type> gu;
+
+      vector_type v;
+      for (int i = 0; i != 5; ++i)
+        v.push_back(gu);
+      VERIFY(v.size() == 5);
+
+      typename vector_type::iterator first = v.begin() + 1;
+      typename vector_type::iterator last = first + 2;
+
+      cont_type c1;
+      InsertRangeHelper<cont_type>::Insert(c1, first, last);
+      VERIFY(c1.size() == 2);
+
+      cont_type c2;
+      InsertRangeHelper<cont_type>::Insert(c2, last, first); // Expected failure
+    }
+
+  template<typename _Tp>
+    void
+    check_insert3()
+    {
+      bool test __attribute__((unused)) = true;
+
+      typedef _Tp cont_type;
+      typedef typename cont_type::value_type cont_val_type;
+      typedef typename CopyableValueType<cont_val_type>::value_type val_type;
+      typedef std::list<val_type> list_type;
+
+      generate_unique<val_type> gu;
+
+      list_type l;
+      for (int i = 0; i != 5; ++i)
+        l.push_back(gu);
+      VERIFY(l.size() == 5);
+
+      typename list_type::iterator first = l.begin(); ++first;
+      typename list_type::iterator last = first; ++last; ++last;
+
+      cont_type c1;
+      InsertRangeHelper<cont_type>::Insert(c1, first, last);
+      VERIFY(c1.size() == 2);
+
+      cont_type c2;
+      InsertRangeHelper<cont_type>::Insert(c2, last, first); // Expected failure
+    }
+}
+
diff --git a/libstdc++-v3/testsuite/util/exception/safety.h b/libstdc++-v3/testsuite/util/exception/safety.h
new file mode 100644
index 000000000..9468bffd8
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/exception/safety.h
@@ -0,0 +1,1304 @@
+// -*- C++ -*-
+
+// Copyright (C) 2009, 2010 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#ifndef _GLIBCXX_EXCEPTION_SAFETY_H
+#define _GLIBCXX_EXCEPTION_SAFETY_H
+
+#include <testsuite_container_traits.h>
+#include <ext/throw_allocator.h>
+
+// Container requirement testing.
+namespace __gnu_test
+{
+  // Base class for exception testing, contains utilities.
+  struct setup_base
+  {
+    typedef std::size_t 				size_type;
+    typedef std::uniform_int_distribution<size_type> 	distribution_type;
+    typedef std::mt19937 				engine_type;
+
+    // Return randomly generated integer on range [0, __max_size].
+    static size_type
+    generate(size_type __max_size)
+    {
+      // Make the generator static...
+      const engine_type engine;
+      const distribution_type distribution;
+      static auto generator = std::bind(distribution, engine,
+					std::placeholders::_1);
+
+      // ... but set the range for this particular invocation here.
+      const typename distribution_type::param_type p(0, __max_size);
+      size_type random = generator(p);
+      if (random < distribution.min() || random > distribution.max())
+	{
+	  std::string __s("setup_base::generate");
+	  __s += "\n";
+	  __s += "random number generated is: ";
+	  char buf[40];
+	  __builtin_sprintf(buf, "%lu", (unsigned long)random);
+	  __s += buf;
+	  __s += " on range [";
+	  __builtin_sprintf(buf, "%lu", (unsigned long)distribution.min());
+	  __s += buf;
+	  __s += ", ";
+	  __builtin_sprintf(buf, "%lu", (unsigned long)distribution.max());
+	  __s += buf;
+	  __s += "]\n";
+	  std::__throw_out_of_range(__s.c_str());
+	}
+      return random;
+    }
+
+    // Given an instantiating type, return a unique value.
+    template<typename _Tp>
+      struct generate_unique
+      {
+	typedef _Tp value_type;
+
+	operator value_type()
+	{
+	  static value_type __ret;
+	  ++__ret;
+	  return __ret;
+	}
+      };
+
+    // Partial specialization for pair.
+    template<typename _Tp1, typename _Tp2>
+      struct generate_unique<std::pair<const _Tp1, _Tp2>>
+      {
+	typedef _Tp1 first_type;
+	typedef _Tp2 second_type;
+	typedef std::pair<const _Tp1, _Tp2> pair_type;
+
+	operator pair_type()
+	{
+	  static first_type _S_1;
+	  static second_type _S_2;
+	  ++_S_1;
+	  ++_S_2;
+	  return pair_type(_S_1, _S_2);
+	}
+      };
+
+    // Partial specialization for throw_value
+    template<typename _Cond>
+      struct generate_unique<__gnu_cxx::throw_value_base<_Cond>>
+      {
+	typedef __gnu_cxx::throw_value_base<_Cond> value_type;
+
+	operator value_type()
+	{
+	  static size_t _S_i(0);
+	  return value_type(_S_i++);
+	}
+      };
+
+
+    // Construct container of size n directly. _Tp == container type.
+    template<typename _Tp>
+      struct make_container_base
+      {
+	_Tp _M_container;
+
+	make_container_base() = default;
+	make_container_base(const size_type n): _M_container(n) { }
+
+	operator _Tp&() { return _M_container; }
+      };
+
+    // Construct container of size n, via multiple insertions. For
+    // associated and unordered types, unique value_type elements are
+    // necessary.
+    template<typename _Tp, bool = traits<_Tp>::is_mapped::value>
+      struct make_insert_container_base
+      : public make_container_base<_Tp>
+      {
+	using make_container_base<_Tp>::_M_container;
+	typedef typename _Tp::value_type value_type;
+
+	make_insert_container_base(const size_type n)
+	{
+	  for (size_type i = 0; i < n; ++i)
+	    {
+	      value_type v = generate_unique<value_type>();
+	      _M_container.insert(v);
+	    }
+	  assert(_M_container.size() == n);
+	}
+      };
+
+    template<typename _Tp>
+      struct make_insert_container_base<_Tp, false>
+      : public make_container_base<_Tp>
+      {
+	using make_container_base<_Tp>::_M_container;
+	typedef typename _Tp::value_type value_type;
+
+	make_insert_container_base(const size_type n)
+	{
+	  for (size_type i = 0; i < n; ++i)
+	    {
+	      value_type v = generate_unique<value_type>();
+	      _M_container.insert(_M_container.end(), v);
+	    }
+	  assert(_M_container.size() == n);
+	}
+      };
+
+    template<typename _Tp, bool = traits<_Tp>::has_size_type_constructor::value>
+      struct make_container_n;
+
+    // Specialization for non-associative types that have a constructor with
+    // a size argument.
+    template<typename _Tp>
+      struct make_container_n<_Tp, true>
+      : public make_container_base<_Tp>
+      {
+	make_container_n(const size_type n) : make_container_base<_Tp>(n) { }
+      };
+
+    template<typename _Tp>
+      struct make_container_n<_Tp, false>
+      : public make_insert_container_base<_Tp>
+      {
+	make_container_n(const size_type n)
+	: make_insert_container_base<_Tp>(n) { }
+      };
+
+
+    // Randomly size and populate a given container reference.
+    // NB: Responsibility for turning off exceptions lies with caller.
+    template<typename _Tp, bool = traits<_Tp>::is_allocator_aware::value>
+      struct populate
+      {
+	typedef _Tp 					container_type;
+	typedef typename container_type::allocator_type	allocator_type;
+	typedef typename container_type::value_type    	value_type;
+
+	populate(_Tp& __container)
+	{
+	  const allocator_type a = __container.get_allocator();
+
+	  // Size test container.
+	  const size_type max_elements = 100;
+	  size_type n = generate(max_elements);
+
+	  // Construct new container.
+	  make_container_n<container_type> made(n);
+	  container_type& tmp = made;
+	  std::swap(tmp, __container);
+	}
+      };
+
+    // Partial specialization, empty.
+    template<typename _Tp>
+      struct populate<_Tp, false>
+      {
+	populate(_Tp&) { }
+      };
+
+    // Compare two containers for equivalence.
+    // Right now, that means size.
+    // Returns true if equal, throws if not.
+    template<typename _Tp>
+      static bool
+      compare(const _Tp& __control, const _Tp& __test)
+      {
+	// Make sure test container is in a consistent state, as
+	// compared to the control container.
+	// NB: Should be equivalent to __test != __control, but
+	// computed without equivalence operators
+	const size_type szt = std::distance(__test.begin(), __test.end());
+	const size_type szc = std::distance(__control.begin(),
+					    __control.end());
+	bool __equal_size = szt == szc;
+
+	// Should test iterator validity before and after exception.
+	bool __equal_it = std::equal(__test.begin(), __test.end(),
+				     __control.begin());
+
+	if (!__equal_size || !__equal_it)
+	  throw std::logic_error("setup_base::compare containers not equal");
+
+	return true;
+      }
+  };
+
+
+  // Containing structure holding functors.
+  struct functor_base : public setup_base
+  {
+    // Abstract the erase function.
+    template<typename _Tp>
+      struct erase_base
+      {
+	typedef typename _Tp::iterator 			iterator;
+	typedef typename _Tp::const_iterator		const_iterator;
+
+	iterator (_Tp::* _F_erase_point)(const_iterator);
+	iterator (_Tp::* _F_erase_range)(const_iterator, const_iterator);
+
+	erase_base()
+	: _F_erase_point(&_Tp::erase), _F_erase_range(&_Tp::erase) { }
+      };
+
+    // Specializations, old C++03 signatures.
+    template<typename _Tp1, typename _Tp2, typename _Tp3>
+      struct erase_base<std::basic_string<_Tp1, _Tp2, _Tp3>>
+      {
+	typedef std::basic_string<_Tp1, _Tp2, _Tp3>     container_type;
+	typedef typename container_type::iterator 	iterator;
+
+	iterator (container_type::* _F_erase_point)(iterator);
+	iterator (container_type::* _F_erase_range)(iterator, iterator);
+
+	erase_base()
+	: _F_erase_point(&container_type::erase),
+	  _F_erase_range(&container_type::erase) { }
+      };
+
+    template<typename _Tp1, typename _Tp2, typename _Tp3,
+	     template <typename, typename, typename> class _Tp4>
+      struct erase_base<__gnu_cxx::__versa_string<_Tp1, _Tp2, _Tp3, _Tp4>>
+      {
+	typedef __gnu_cxx::__versa_string<_Tp1, _Tp2, _Tp3, _Tp4>
+	                                                container_type;
+	typedef typename container_type::iterator 	iterator;
+
+	iterator (container_type::* _F_erase_point)(iterator);
+	iterator (container_type::* _F_erase_range)(iterator, iterator);
+
+	erase_base()
+	: _F_erase_point(&container_type::erase),
+	  _F_erase_range(&container_type::erase) { }
+      };
+
+    template<typename _Tp1, typename _Tp2>
+      struct erase_base<std::deque<_Tp1, _Tp2>>
+      {
+	typedef std::deque<_Tp1, _Tp2> 		        container_type;
+	typedef typename container_type::iterator 	iterator;
+
+	iterator (container_type::* _F_erase_point)(iterator);
+	iterator (container_type::* _F_erase_range)(iterator, iterator);
+
+	erase_base()
+	: _F_erase_point(&container_type::erase),
+	  _F_erase_range(&container_type::erase) { }
+      };
+
+    template<typename _Tp1, typename _Tp2>
+      struct erase_base<std::list<_Tp1, _Tp2>>
+      {
+	typedef std::list<_Tp1, _Tp2> 		        container_type;
+	typedef typename container_type::iterator 	iterator;
+
+	iterator (container_type::* _F_erase_point)(iterator);
+	iterator (container_type::* _F_erase_range)(iterator, iterator);
+
+	erase_base()
+	: _F_erase_point(&container_type::erase),
+	  _F_erase_range(&container_type::erase) { }
+      };
+
+    template<typename _Tp1, typename _Tp2>
+      struct erase_base<std::vector<_Tp1, _Tp2>>
+      {
+	typedef std::vector<_Tp1, _Tp2>		        container_type;
+	typedef typename container_type::iterator 	iterator;
+
+	iterator (container_type::* _F_erase_point)(iterator);
+	iterator (container_type::* _F_erase_range)(iterator, iterator);
+
+	erase_base()
+	: _F_erase_point(&container_type::erase),
+	  _F_erase_range(&container_type::erase) { }
+      };
+
+    // Specialization, as forward_list has erase_after.
+    template<typename _Tp1, typename _Tp2>
+      struct erase_base<std::forward_list<_Tp1, _Tp2>>
+      {
+	typedef std::forward_list<_Tp1, _Tp2> 		container_type;
+	typedef typename container_type::iterator 	iterator;
+	typedef typename container_type::const_iterator const_iterator;
+
+	iterator (container_type::* _F_erase_point)(const_iterator);
+	iterator (container_type::* _F_erase_range)(const_iterator,
+						    const_iterator);
+
+	erase_base()
+	: _F_erase_point(&container_type::erase_after),
+	  _F_erase_range(&container_type::erase_after) { }
+      };
+
+    template<typename _Tp,
+	     bool = traits<_Tp>::has_erase::value,
+	     bool = traits<_Tp>::has_erase_after::value>
+      struct erase_point;
+
+    // Specialization for most containers.
+    template<typename _Tp>
+      struct erase_point<_Tp, true, false> : public erase_base<_Tp>
+      {
+	using erase_base<_Tp>::_F_erase_point;
+
+	void
+	operator()(_Tp& __container)
+	{
+	  try
+	    {
+	      // NB: Should be equivalent to size() member function, but
+	      // computed with begin() and end().
+	      const size_type sz = std::distance(__container.begin(),
+						 __container.end());
+
+	      // NB: Lowest common denominator: use forward iterator operations.
+	      auto i = __container.begin();
+	      std::advance(i, generate(sz));
+
+	      // Makes it easier to think of this as __container.erase(i)
+	      (__container.*_F_erase_point)(i);
+	    }
+	  catch(const __gnu_cxx::forced_error&)
+	    { throw; }
+	}
+      };
+
+    // Specialization for forward_list.
+    template<typename _Tp>
+      struct erase_point<_Tp, false, true> : public erase_base<_Tp>
+      {
+	using erase_base<_Tp>::_F_erase_point;
+
+	void
+	operator()(_Tp& __container)
+	{
+	  try
+	    {
+	      // NB: Should be equivalent to size() member function, but
+	      // computed with begin() and end().
+	      const size_type sz = std::distance(__container.begin(),
+						 __container.end());
+
+	      // NB: Lowest common denominator: use forward iterator operations.
+	      auto i = __container.before_begin();
+	      std::advance(i, generate(sz));
+
+	      // Makes it easier to think of this as __container.erase(i)
+	      (__container.*_F_erase_point)(i);
+	    }
+	  catch(const __gnu_cxx::forced_error&)
+	    { throw; }
+	}
+      };
+
+    // Specialization, empty.
+    template<typename _Tp>
+      struct erase_point<_Tp, false, false>
+      {
+	void
+	operator()(_Tp&) { }
+      };
+
+
+    template<typename _Tp,
+	     bool = traits<_Tp>::has_erase::value,
+	     bool = traits<_Tp>::has_erase_after::value>
+      struct erase_range;
+
+    // Specialization for most containers.
+    template<typename _Tp>
+      struct erase_range<_Tp, true, false> : public erase_base<_Tp>
+      {
+	using erase_base<_Tp>::_F_erase_range;
+
+	void
+	operator()(_Tp& __container)
+	{
+	  try
+	    {
+	      const size_type sz = std::distance(__container.begin(),
+						 __container.end());
+	      size_type s1 = generate(sz);
+	      size_type s2 = generate(sz);
+	      auto i1 = __container.begin();
+	      auto i2 = __container.begin();
+	      std::advance(i1, std::min(s1, s2));
+	      std::advance(i2, std::max(s1, s2));
+
+	      // Makes it easier to think of this as __container.erase(i1, i2).
+	      (__container.*_F_erase_range)(i1, i2);
+	    }
+	  catch(const __gnu_cxx::forced_error&)
+	    { throw; }
+	}
+      };
+
+    // Specialization for forward_list.
+    template<typename _Tp>
+      struct erase_range<_Tp, false, true> : public erase_base<_Tp>
+      {
+	using erase_base<_Tp>::_F_erase_range;
+
+	void
+	operator()(_Tp& __container)
+	{
+	  try
+	    {
+	      const size_type sz = std::distance(__container.begin(),
+						 __container.end());
+	      size_type s1 = generate(sz);
+	      size_type s2 = generate(sz);
+	      auto i1 = __container.before_begin();
+	      auto i2 = __container.before_begin();
+	      std::advance(i1, std::min(s1, s2));
+	      std::advance(i2, std::max(s1, s2));
+
+	      // Makes it easier to think of this as __container.erase(i1, i2).
+	      (__container.*_F_erase_range)(i1, i2);
+	    }
+	  catch(const __gnu_cxx::forced_error&)
+	    { throw; }
+	}
+      };
+
+    // Specialization, empty.
+    template<typename _Tp>
+      struct erase_range<_Tp, false, false>
+      {
+	void
+	operator()(_Tp&) { }
+      };
+
+
+    template<typename _Tp, bool = traits<_Tp>::has_push_pop::value>
+      struct pop_front
+      {
+	void
+	operator()(_Tp& __container)
+	{
+	  try
+	    {
+	      __container.pop_front();
+	    }
+	  catch(const __gnu_cxx::forced_error&)
+	    { throw; }
+	}
+      };
+
+    // Specialization, empty.
+    template<typename _Tp>
+      struct pop_front<_Tp, false>
+      {
+	void
+	operator()(_Tp&) { }
+      };
+
+
+    template<typename _Tp, bool = traits<_Tp>::has_push_pop::value
+				  && traits<_Tp>::is_reversible::value>
+      struct pop_back
+      {
+	void
+	operator()(_Tp& __container)
+	{
+	  try
+	    {
+	      __container.pop_back();
+	    }
+	  catch(const __gnu_cxx::forced_error&)
+	    { throw; }
+	}
+      };
+
+    // Specialization, empty.
+    template<typename _Tp>
+      struct pop_back<_Tp, false>
+      {
+	void
+	operator()(_Tp&) { }
+      };
+
+
+    template<typename _Tp, bool = traits<_Tp>::has_push_pop::value>
+      struct push_front
+      {
+	typedef _Tp 					container_type;
+	typedef typename container_type::value_type    	value_type;
+
+	void
+	operator()(_Tp& __test)
+	{
+	  try
+	    {
+	      const value_type cv = generate_unique<value_type>();
+	      __test.push_front(cv);
+	    }
+	  catch(const __gnu_cxx::forced_error&)
+	    { throw; }
+	}
+
+	// Assumes containers start out equivalent.
+	void
+	operator()(_Tp& __control, _Tp& __test)
+	{
+	  try
+	    {
+	      const value_type cv = generate_unique<value_type>();
+	      __test.push_front(cv);
+	    }
+	  catch(const __gnu_cxx::forced_error&)
+	    { throw; }
+	}
+    };
+
+    // Specialization, empty.
+    template<typename _Tp>
+      struct push_front<_Tp, false>
+      {
+	void
+	operator()(_Tp&) { }
+
+	void
+	operator()(_Tp&, _Tp&) { }
+      };
+
+
+    template<typename _Tp, bool = traits<_Tp>::has_push_pop::value
+				  && traits<_Tp>::is_reversible::value>
+      struct push_back
+      {
+	typedef _Tp 					container_type;
+	typedef typename container_type::value_type    	value_type;
+
+	void
+	operator()(_Tp& __test)
+	{
+	  try
+	    {
+	      const value_type cv = generate_unique<value_type>();
+	      __test.push_back(cv);
+	    }
+	  catch(const __gnu_cxx::forced_error&)
+	    { throw; }
+	}
+
+	// Assumes containers start out equivalent.
+	void
+	operator()(_Tp& __control, _Tp& __test)
+	{
+	  try
+	    {
+	      const value_type cv = generate_unique<value_type>();
+	      __test.push_back(cv);
+	    }
+	  catch(const __gnu_cxx::forced_error&)
+	    { throw; }
+	}
+    };
+
+    // Specialization, empty.
+    template<typename _Tp>
+      struct push_back<_Tp, false>
+      {
+	void
+	operator()(_Tp&) { }
+
+	void
+	operator()(_Tp&, _Tp&) { }
+      };
+
+
+    // Abstract the insert function into two parts:
+    // 1, insert_base_functions == holds function pointer
+    // 2, insert_base == links function pointer to class insert method
+    template<typename _Tp>
+      struct insert_base
+      {
+	typedef typename _Tp::iterator 			iterator;
+	typedef typename _Tp::const_iterator    	const_iterator;
+	typedef typename _Tp::value_type 		value_type;
+
+	iterator (_Tp::* _F_insert_point)(const_iterator, const value_type&);
+
+	insert_base() : _F_insert_point(&_Tp::insert) { }
+      };
+
+    // Specializations, old C++03 signatures.
+    template<typename _Tp1, typename _Tp2>
+      struct insert_base<std::deque<_Tp1, _Tp2>>
+      {
+	typedef std::deque<_Tp1, _Tp2> 	                container_type;
+	typedef typename container_type::iterator 	iterator;
+	typedef typename container_type::value_type 	value_type;
+
+	iterator (container_type::* _F_insert_point)(iterator,
+						     const value_type&);
+
+	insert_base() : _F_insert_point(&container_type::insert) { }
+      };
+
+    template<typename _Tp1, typename _Tp2>
+      struct insert_base<std::list<_Tp1, _Tp2>>
+      {
+	typedef std::list<_Tp1, _Tp2>    	        container_type;
+	typedef typename container_type::iterator 	iterator;
+	typedef typename container_type::value_type 	value_type;
+
+	iterator (container_type::* _F_insert_point)(iterator,
+						     const value_type&);
+
+	insert_base() : _F_insert_point(&container_type::insert) { }
+      };
+
+    template<typename _Tp1, typename _Tp2>
+      struct insert_base<std::vector<_Tp1, _Tp2>>
+      {
+	typedef std::vector<_Tp1, _Tp2> 	        container_type;
+	typedef typename container_type::iterator 	iterator;
+	typedef typename container_type::value_type 	value_type;
+
+	iterator (container_type::* _F_insert_point)(iterator,
+						     const value_type&);
+
+	insert_base() : _F_insert_point(&container_type::insert) { }
+      };
+
+    // Specialization, as string insertion has a different signature.
+    template<typename _Tp1, typename _Tp2, typename _Tp3>
+      struct insert_base<std::basic_string<_Tp1, _Tp2, _Tp3>>
+      {
+	typedef std::basic_string<_Tp1, _Tp2, _Tp3> 	container_type;
+	typedef typename container_type::iterator 	iterator;
+	typedef typename container_type::value_type 	value_type;
+
+	iterator (container_type::* _F_insert_point)(iterator, value_type);
+
+	insert_base() : _F_insert_point(&container_type::insert) { }
+      };
+
+    // Likewise for __versa_string.
+    template<typename _Tp1, typename _Tp2, typename _Tp3,
+	     template <typename, typename, typename> class _Tp4>
+      struct insert_base<__gnu_cxx::__versa_string<_Tp1, _Tp2, _Tp3, _Tp4>>
+      {
+	typedef __gnu_cxx::__versa_string<_Tp1, _Tp2, _Tp3, _Tp4>
+	                                                container_type;
+	typedef typename container_type::iterator 	iterator;
+	typedef typename container_type::value_type 	value_type;
+
+	iterator (container_type::* _F_insert_point)(iterator, value_type);
+
+	insert_base() : _F_insert_point(&container_type::insert) { }
+      };
+
+    // Specialization, as forward_list has insert_after.
+    template<typename _Tp1, typename _Tp2>
+      struct insert_base<std::forward_list<_Tp1, _Tp2>>
+      {
+	typedef std::forward_list<_Tp1, _Tp2> container_type;
+	typedef typename container_type::iterator 	iterator;
+	typedef typename container_type::const_iterator const_iterator;
+	typedef typename container_type::value_type 	value_type;
+
+	iterator (container_type::* _F_insert_point)(const_iterator,
+						     const value_type&);
+
+	insert_base() : _F_insert_point(&container_type::insert_after) { }
+      };
+
+    template<typename _Tp,
+	     bool = traits<_Tp>::has_insert::value,
+	     bool = traits<_Tp>::has_insert_after::value>
+      struct insert_point;
+
+    // Specialization for most containers.
+    template<typename _Tp>
+      struct insert_point<_Tp, true, false> : public insert_base<_Tp>
+      {
+	typedef _Tp 				       	container_type;
+	typedef typename container_type::value_type 	value_type;
+	using insert_base<_Tp>::_F_insert_point;
+
+	void
+	operator()(_Tp& __test)
+	{
+	  try
+	    {
+	      const value_type cv = generate_unique<value_type>();
+	      const size_type sz = std::distance(__test.begin(), __test.end());
+	      size_type s = generate(sz);
+	      auto i = __test.begin();
+	      std::advance(i, s);
+	      (__test.*_F_insert_point)(i, cv);
+	    }
+	  catch(const __gnu_cxx::forced_error&)
+	    { throw; }
+	}
+
+	// Assumes containers start out equivalent.
+	void
+	operator()(_Tp& __control, _Tp& __test)
+	{
+	  try
+	    {
+	      const value_type cv = generate_unique<value_type>();
+	      const size_type sz = std::distance(__test.begin(), __test.end());
+	      size_type s = generate(sz);
+	      auto i = __test.begin();
+	      std::advance(i, s);
+	      (__test.*_F_insert_point)(i, cv);
+	    }
+	  catch(const __gnu_cxx::forced_error&)
+	    { throw; }
+ 	}
+      };
+
+    // Specialization for forward_list.
+    template<typename _Tp>
+      struct insert_point<_Tp, false, true> : public insert_base<_Tp>
+      {
+	typedef _Tp 				       	container_type;
+	typedef typename container_type::value_type 	value_type;
+	using insert_base<_Tp>::_F_insert_point;
+
+	void
+	operator()(_Tp& __test)
+	{
+	  try
+	    {
+	      const value_type cv = generate_unique<value_type>();
+	      const size_type sz = std::distance(__test.begin(), __test.end());
+	      size_type s = generate(sz);
+	      auto i = __test.before_begin();
+	      std::advance(i, s);
+	      (__test.*_F_insert_point)(i, cv);
+	    }
+	  catch(const __gnu_cxx::forced_error&)
+	    { throw; }
+	}
+
+	// Assumes containers start out equivalent.
+	void
+	operator()(_Tp& __control, _Tp& __test)
+	{
+	  try
+	    {
+	      const value_type cv = generate_unique<value_type>();
+	      const size_type sz = std::distance(__test.begin(), __test.end());
+	      size_type s = generate(sz);
+	      auto i = __test.before_begin();
+	      std::advance(i, s);
+	      (__test.*_F_insert_point)(i, cv);
+	    }
+	  catch(const __gnu_cxx::forced_error&)
+	    { throw; }
+ 	}
+      };
+
+    // Specialization, empty.
+    template<typename _Tp>
+      struct insert_point<_Tp, false, false>
+      {
+	void
+	operator()(_Tp&) { }
+
+	void
+	operator()(_Tp&, _Tp&) { }
+      };
+
+
+    template<typename _Tp, bool = traits<_Tp>::is_associative::value
+				  || traits<_Tp>::is_unordered::value>
+      struct clear
+      {
+	void
+	operator()(_Tp& __container)
+	{
+	  try
+	    {
+	      __container.clear();
+	    }
+	  catch(const __gnu_cxx::forced_error&)
+	    { throw; }
+	}
+      };
+
+    // Specialization, empty.
+    template<typename _Tp>
+      struct clear<_Tp, false>
+      {
+	void
+	operator()(_Tp&) { }
+      };
+
+
+    template<typename _Tp, bool = traits<_Tp>::is_unordered::value>
+      struct rehash
+      {
+	void
+	operator()(_Tp& __test)
+	{
+	  try
+	    {
+	      size_type s = generate(__test.bucket_count());
+	      __test.rehash(s);
+	    }
+	  catch(const __gnu_cxx::forced_error&)
+	    { throw; }
+	}
+
+	void
+	operator()(_Tp& __control, _Tp& __test)
+	{
+	  try
+	    {
+	      size_type s = generate(__test.bucket_count());
+	      __test.rehash(s);
+	    }
+	  catch(const __gnu_cxx::forced_error&)
+	    {
+	      // Also check hash status.
+	      bool fail(false);
+	      if (__control.load_factor() != __test.load_factor())
+		fail = true;
+	      if (__control.max_load_factor() != __test.max_load_factor())
+		fail = true;
+	      if (__control.bucket_count() != __test.bucket_count())
+		fail = true;
+	      if (__control.max_bucket_count() != __test.max_bucket_count())
+		fail = true;
+
+	      if (fail)
+		{
+		  char buf[40];
+		  std::string __s("setup_base::rehash "
+				  "containers not equal");
+		  __s += "\n";
+		  __s += "\n";
+		  __s += "\t\t\tcontrol : test";
+		  __s += "\n";
+		  __s += "load_factor\t\t";
+		  __builtin_sprintf(buf, "%lu", __control.load_factor());
+		  __s += buf;
+		  __s += " : ";
+		  __builtin_sprintf(buf, "%lu", __test.load_factor());
+		  __s += buf;
+		  __s += "\n";
+
+		  __s += "max_load_factor\t\t";
+		  __builtin_sprintf(buf, "%lu", __control.max_load_factor());
+		  __s += buf;
+		  __s += " : ";
+		  __builtin_sprintf(buf, "%lu", __test.max_load_factor());
+		  __s += buf;
+		  __s += "\n";
+
+		  __s += "bucket_count\t\t";
+		  __builtin_sprintf(buf, "%lu", __control.bucket_count());
+		  __s += buf;
+		  __s += " : ";
+		  __builtin_sprintf(buf, "%lu", __test.bucket_count());
+		  __s += buf;
+		  __s += "\n";
+
+		  __s += "max_bucket_count\t";
+		  __builtin_sprintf(buf, "%lu", __control.max_bucket_count());
+		  __s += buf;
+		  __s += " : ";
+		  __builtin_sprintf(buf, "%lu", __test.max_bucket_count());
+		  __s += buf;
+		  __s += "\n";
+
+		  std::__throw_logic_error(__s.c_str());
+		}
+	    }
+ 	}
+      };
+
+    // Specialization, empty.
+    template<typename _Tp>
+      struct rehash<_Tp, false>
+      {
+	void
+	operator()(_Tp&) { }
+
+	void
+	operator()(_Tp&, _Tp&) { }
+      };
+
+
+    template<typename _Tp>
+      struct swap
+      {
+	_Tp _M_other;
+
+	void
+	operator()(_Tp& __container)
+	{
+	  try
+	    {
+	      __container.swap(_M_other);
+	    }
+	  catch(const __gnu_cxx::forced_error&)
+	    { throw; }
+	}
+      };
+
+
+    template<typename _Tp>
+      struct iterator_operations
+      {
+	typedef _Tp 					container_type;
+	typedef typename container_type::iterator       iterator;
+
+	void
+	operator()(_Tp& __container)
+	{
+	  try
+	    {
+	      // Any will do.
+	      iterator i = __container.begin();
+	      iterator __attribute__((unused)) icopy(i);
+	      iterator __attribute__((unused)) iassign = i;
+	    }
+	  catch(const __gnu_cxx::forced_error&)
+	    { throw; }
+	}
+      };
+
+
+    template<typename _Tp>
+      struct const_iterator_operations
+      {
+	typedef _Tp 					container_type;
+	typedef typename container_type::const_iterator	const_iterator;
+
+	void
+	operator()(_Tp& __container)
+	{
+	  try
+	    {
+	      // Any will do.
+	      const_iterator i = __container.begin();
+	      const_iterator __attribute__((unused)) icopy(i);
+	      const_iterator __attribute__((unused)) iassign = i;
+	    }
+	  catch(const __gnu_cxx::forced_error&)
+	    { throw; }
+	}
+      };
+  };
+
+  // Base class for exception tests.
+  template<typename _Tp>
+    struct test_base: public functor_base
+    {
+      typedef _Tp 					container_type;
+
+      typedef functor_base				base_type;
+      typedef populate<container_type> 	       		populate;
+      typedef make_container_n<container_type> 	       	make_container_n;
+
+      typedef clear<container_type> 		       	clear;
+      typedef erase_point<container_type> 	       	erase_point;
+      typedef erase_range<container_type> 	       	erase_range;
+      typedef insert_point<container_type> 	       	insert_point;
+      typedef pop_front<container_type> 	       	pop_front;
+      typedef pop_back<container_type> 			pop_back;
+      typedef push_front<container_type> 	       	push_front;
+      typedef push_back<container_type> 	       	push_back;
+      typedef rehash<container_type> 			rehash;
+      typedef swap<container_type> 			swap;
+      typedef iterator_operations<container_type>	iterator_ops;
+      typedef const_iterator_operations<container_type>	const_iterator_ops;
+
+      using base_type::compare;
+
+      // Functor objects.
+      clear			_M_clear;
+      erase_point		_M_erasep;
+      erase_range		_M_eraser;
+      insert_point		_M_insertp;
+      pop_front			_M_popf;
+      pop_back			_M_popb;
+      push_front	       	_M_pushf;
+      push_back			_M_pushb;
+      rehash			_M_rehash;
+      swap			_M_swap;
+
+      iterator_ops	       	_M_iops;
+      const_iterator_ops	_M_ciops;
+    };
+
+
+  // Run through all member functions for basic exception safety
+  // guarantee: no resource leaks when exceptions are thrown.
+  //
+  // Types of resources checked: memory.
+  //
+  // For each member function, use throw_value and throw_allocator as
+  // value_type and allocator_type to force potential exception safety
+  // errors.
+  //
+  // NB: Assumes
+  // _Tp::value_type is __gnu_cxx::throw_value_*
+  // _Tp::allocator_type is __gnu_cxx::throw_allocator_*
+  // And that the _Cond template parameter for them both is
+  // __gnu_cxx::limit_condition.
+  template<typename _Tp>
+    struct basic_safety : public test_base<_Tp>
+    {
+      typedef _Tp 					container_type;
+      typedef test_base<container_type>			base_type;
+      typedef typename base_type::populate 		populate;
+      typedef std::function<void(container_type&)> 	function_type;
+      typedef __gnu_cxx::limit_condition		condition_type;
+
+      using base_type::generate;
+
+      container_type 					_M_container;
+      std::vector<function_type>			_M_functions;
+
+      basic_safety() { run(); }
+
+      void
+      run()
+      {
+	// Setup.
+	condition_type::never_adjustor off;
+	
+	// Construct containers.
+	populate p1(_M_container);
+	populate p2(base_type::_M_swap._M_other);
+	
+	// Construct list of member functions to exercise.
+	_M_functions.push_back(function_type(base_type::_M_iops));
+	_M_functions.push_back(function_type(base_type::_M_ciops));
+	
+	_M_functions.push_back(function_type(base_type::_M_erasep));
+	_M_functions.push_back(function_type(base_type::_M_eraser));
+	_M_functions.push_back(function_type(base_type::_M_insertp));
+	_M_functions.push_back(function_type(base_type::_M_popf));
+	_M_functions.push_back(function_type(base_type::_M_popb));
+	_M_functions.push_back(function_type(base_type::_M_pushf));
+	_M_functions.push_back(function_type(base_type::_M_pushb));
+	_M_functions.push_back(function_type(base_type::_M_rehash));
+	_M_functions.push_back(function_type(base_type::_M_swap));
+	
+	// Last.
+	_M_functions.push_back(function_type(base_type::_M_clear));
+
+	// Run tests.
+	for (auto i = _M_functions.begin(); i != _M_functions.end(); ++i)
+	  {
+	    function_type& f = *i;
+	    run_steps_to_limit(f);
+	  }
+      }
+
+      template<typename _Funct>
+	void
+	run_steps_to_limit(const _Funct& __f)
+	{
+	  size_t i(1);
+	  bool exit(false);
+	  auto a = _M_container.get_allocator();
+
+	  do
+	    {
+	      // Use the current step as an allocator label.
+	      a.set_label(i);
+
+	      try
+		{
+		  condition_type::limit_adjustor limit(i);
+		  __f(_M_container);
+
+		  // If we get here, done.
+		  exit = true;
+		}
+	      catch(const __gnu_cxx::forced_error&)
+		{
+		  // Check this step for allocations.
+		  // NB: Will throw std::logic_error if allocations.
+		  a.check_allocated(i);
+
+		  // Check memory allocated with operator new.
+
+		  ++i;
+		}
+	    }
+	  while (!exit);
+
+	  // Log count info.
+	  std::cout << __f.target_type().name() << std::endl;
+	  std::cout << "end count " << i << std::endl;
+	}
+  };
+
+
+  // Run through all member functions with a no throw requirement, sudden death.
+  // all: member functions erase, pop_back, pop_front, swap
+  //      iterator copy ctor, assignment operator
+  // unordered and associative: clear
+  // NB: Assumes _Tp::allocator_type is __gnu_cxx::throw_allocator_random.
+  template<typename _Tp>
+    struct generation_prohibited : public test_base<_Tp>
+    {
+      typedef _Tp 					container_type;
+      typedef test_base<container_type>			base_type;
+      typedef typename base_type::populate 		populate;
+      typedef __gnu_cxx::random_condition		condition_type;
+
+      container_type 					_M_container;
+
+      generation_prohibited()  { run(); }
+
+      void
+      run()
+      {
+	// Furthermore, assumes that the test functor will throw
+	// forced_exception via throw_allocator, that all errors are
+	// propagated and in error. Sudden death!
+
+	// Setup.
+	{
+	  condition_type::never_adjustor off;
+	  populate p1(_M_container);
+	  populate p2(base_type::_M_swap._M_other);
+	}
+
+	// Run tests.
+	{
+	  condition_type::always_adjustor on;
+
+	  // NB: Vector and deque are special, erase can throw if the copy
+	  // constructor or assignment operator of value_type throws.
+	  if (!traits<container_type>::has_throwing_erase::value)
+	    {
+	      _M_erasep(_M_container);
+	      _M_eraser(_M_container);
+	    }
+
+	  _M_popf(_M_container);
+	  _M_popb(_M_container);
+
+	  _M_iops(_M_container);
+	  _M_ciops(_M_container);
+
+	  _M_swap(_M_container);
+
+	  // Last.
+	  _M_clear(_M_container);
+	}
+      }
+    };
+
+
+  // Test strong exception guarantee.
+  // Run through all member functions with a roll-back, consistent
+  // coherent requirement.
+  // all: member functions insert of a single element, push_back, push_front
+  // unordered: rehash
+  template<typename _Tp>
+    struct propagation_consistent : public test_base<_Tp>
+    {
+      typedef _Tp 					container_type;
+      typedef test_base<container_type>			base_type;
+      typedef typename base_type::populate 		populate;
+      typedef std::function<void(container_type&)> 	function_type;
+      typedef __gnu_cxx::limit_condition		condition_type;
+
+      using base_type::compare;
+
+      container_type 					_M_container_test;
+      container_type 					_M_container_control;
+      std::vector<function_type>			_M_functions;
+
+      propagation_consistent() { run(); }
+
+      void
+      sync()
+      { _M_container_test = _M_container_control; }
+
+      // Run test.
+      void
+      run()
+      {
+	// Setup.
+	condition_type::never_adjustor off;
+
+	// Construct containers.
+	populate p(_M_container_control);
+	sync();
+
+	// Construct list of member functions to exercise.
+	_M_functions.push_back(function_type(base_type::_M_pushf));
+	_M_functions.push_back(function_type(base_type::_M_pushb));
+	_M_functions.push_back(function_type(base_type::_M_insertp));
+	_M_functions.push_back(function_type(base_type::_M_rehash));
+
+	// Run tests.
+	for (auto i = _M_functions.begin(); i != _M_functions.end(); ++i)
+	  {
+	    function_type& f = *i;
+	    run_steps_to_limit(f);
+	  }
+      }
+
+      template<typename _Funct>
+	void
+	run_steps_to_limit(const _Funct& __f)
+	{
+	  size_t i(1);
+	  bool exit(false);
+
+	  do
+	    {
+	      sync();
+
+	      try
+		{
+		  condition_type::limit_adjustor limit(i);
+		  __f(_M_container_test);
+
+		  // If we get here, done.
+		  exit = true;
+		}
+	      catch(const __gnu_cxx::forced_error&)
+		{
+		  compare(_M_container_control, _M_container_test);
+		  ++i;
+		}
+	    }
+	  while (!exit);
+
+	  // Log count info.
+	  std::cout << __f.target_type().name() << std::endl;
+	  std::cout << "end count " << i << std::endl;
+	}
+    };
+
+} // namespace __gnu_test
+
+#endif
diff --git a/libstdc++-v3/testsuite/util/hash_fn/dna_str_limit.hpp b/libstdc++-v3/testsuite/util/hash_fn/dna_str_limit.hpp
new file mode 100644
index 000000000..e81804ec0
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/hash_fn/dna_str_limit.hpp
@@ -0,0 +1,62 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 dna_str_limit.hpp
+ * Contains a function for finding the numer of characters
+ *    to access in a DNA string.
+ */
+
+#ifndef PB_DS_DNA_STR_LIMIT_HPP
+#define PB_DS_DNA_STR_LIMIT_HPP
+
+#include <string>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    size_t
+    dna_str_limit(size_t size)
+    {
+      size_t ret = 1;
+      size_t calc_size = 4;
+      while (calc_size < size)
+	{
+	  ++ret;
+	  calc_size = calc_size << 2;
+	}
+      return ret;
+    }
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_DNA_STR_LIMIT_HPP
diff --git a/libstdc++-v3/testsuite/util/hash_fn/limit_string_hash_fn.hpp b/libstdc++-v3/testsuite/util/hash_fn/limit_string_hash_fn.hpp
new file mode 100644
index 000000000..d040e1161
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/hash_fn/limit_string_hash_fn.hpp
@@ -0,0 +1,72 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 limit_string_hash_fn.hpp
+ * Contains a string hash function.
+ */
+
+#ifndef PB_DS_LIMIT_STRING_HASH_FN_HPP
+#define PB_DS_LIMIT_STRING_HASH_FN_HPP
+
+#include <string>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    struct limit_string_hash_fn
+    {
+      static size_t _S_max;
+
+      inline size_t
+      operator()(const std::string& r_str) const
+      {
+	size_t ret = 0;
+	std::string::const_iterator b = r_str.begin();
+	std::string::const_iterator e = r_str.end();
+
+	size_t i = 0;
+	while (b != e&&  i < _S_max)
+	  {
+	    ret *= 5;
+	    ret += static_cast<size_t>(*(b++));
+	  }
+	return ret;
+      }
+    };
+
+    size_t limit_string_hash_fn::_S_max;
+
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif
diff --git a/libstdc++-v3/testsuite/util/hash_fn/string_hash_fn.hpp b/libstdc++-v3/testsuite/util/hash_fn/string_hash_fn.hpp
new file mode 100644
index 000000000..9a1a415a0
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/hash_fn/string_hash_fn.hpp
@@ -0,0 +1,68 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 string_hash_fn.hpp
+ * Contains a string hash function.
+ */
+
+#ifndef PB_DS_STRING_HASH_FN_HPP
+#define PB_DS_STRING_HASH_FN_HPP
+
+#include <string>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    struct string_hash_fn
+    {
+      template<typename String_T>
+      inline size_t
+      operator()(const String_T& r_str) const
+      {
+	typedef typename String_T::const_iterator const_iterator;
+	const_iterator b = r_str.begin();
+	const_iterator e = r_str.end();
+
+	size_t ret = 0;
+	while (b != e)
+	  {
+	    ret *= 5;
+	    ret += static_cast<size_t>(*(b++));
+	  }
+	return ret;
+      }
+    };
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif
diff --git a/libstdc++-v3/testsuite/util/hash_fn/string_ranged_hash_fn.hpp b/libstdc++-v3/testsuite/util/hash_fn/string_ranged_hash_fn.hpp
new file mode 100644
index 000000000..fcf9f60ac
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/hash_fn/string_ranged_hash_fn.hpp
@@ -0,0 +1,99 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 string_ranged_hash_fn.hpp
+ * Contains a ranged string hash function.
+ */
+
+#ifndef PB_DS_STRING_RANGED_HASH_FN_HPP
+#define PB_DS_STRING_RANGED_HASH_FN_HPP
+
+#include <string>
+#include <hash_fn/dna_str_limit.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    template<typename Comb_Fn>
+    class string_ranged_hash_fn : public Comb_Fn
+    {
+    private:
+      size_t _M_limit;
+
+    public:
+      typedef Comb_Fn comb_fn;
+      typedef detail::comb_hash_fn_string_form<comb_fn> string_form;
+
+      inline size_t
+      operator()(const std::string& r_str) const
+      {
+	size_t ret = 0;
+	std::string::const_iterator b = r_str.begin();
+	std::string::const_iterator e = r_str.end();
+
+	size_t i = 0;
+	while (i < _M_limit&&  b != e)
+	  {
+	    ret *= 5;
+	    ret += static_cast<size_t>(*(b++));
+	    ++i;
+	  }
+	return (comb_fn::operator()(ret));
+      }
+
+      void
+      swap(string_ranged_hash_fn<Comb_Fn>& other)
+      {
+	std::swap(_M_limit, other._M_limit);
+	comb_fn::swap(other);
+      }
+
+      void
+      notify_resized(size_t new_size)
+      {
+	comb_fn::notify_resized(new_size);
+	_M_limit = dna_str_limit(new_size);
+      }
+
+      static std::string
+      name()
+      { return ("string_ranged_hash_fn_" + string_form<comb_fn>::name()); }
+
+      static std::string
+      desc()
+      { return ("string ranged-hash using" + string_form<comb_fn>::desc()); }
+    };
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/libstdc++-v3/testsuite/util/hash_fn/string_ranged_probe_fn.hpp b/libstdc++-v3/testsuite/util/hash_fn/string_ranged_probe_fn.hpp
new file mode 100644
index 000000000..c74991658
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/hash_fn/string_ranged_probe_fn.hpp
@@ -0,0 +1,103 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 string_ranged_probe_fn.hpp
+ * Contains a ranged string probe function.
+ */
+
+#ifndef PB_DS_STRING_RANGED_PROBE_FN_HPP
+#define PB_DS_STRING_RANGED_PROBE_FN_HPP
+
+#include <string>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    template<typename Comb_Fn, typename Probe_Fn>
+    class string_ranged_probe_fn : public Probe_Fn, public Comb_Fn
+    {
+    private:
+      size_t _M_limit;
+
+    public:
+      typedef Comb_Fn comb_fn;
+      typedef Probe_Fn probe_fn;
+      typedef detail::comb_hash_fn_string_form<comb_fn> string_form;
+
+      inline size_t
+      operator()(const std::string& r_str) const
+      {
+	size_t ret = 0;
+	std::string::const_iterator b = r_str.begin();
+	std::string::const_iterator e = r_str.end();
+
+	size_t i = 0;
+	while (i < _M_limit&&  b != e)
+	  {
+	    ret *= 5;
+	    ret += static_cast<size_t>(*(b++));
+	    ++i;
+	  }
+	return (comb_fn::operator()(ret));
+      }
+
+      inline size_t
+      operator()(const std::string&, const size_t hash, size_t i) const
+      { return comb_fn::operator()(hash + probe_fn::operator()(i)); }
+
+      void
+      swap(string_ranged_probe_fn<Comb_Fn, Probe_Fn>& other)
+      {
+	std::swap(_M_limit, other._M_limit);
+	comb_fn::swap(other);
+      }
+
+      void
+      notify_resized(size_t new_size)
+      {
+	comb_fn::notify_resized(new_size);
+	_M_limit = dna_str_limit(new_size);
+      }
+
+      static std::string
+      name()
+      { return ("string_ranged_probe_fn_" + string_form<comb_fn>::name()); }
+
+      static std::string
+      desc()
+      { return ("string ranged-probe using" + string_form<comb_fn>::desc());}
+    };
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif
diff --git a/libstdc++-v3/testsuite/util/io/illegal_input_error.hpp b/libstdc++-v3/testsuite/util/io/illegal_input_error.hpp
new file mode 100644
index 000000000..79f003b77
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/io/illegal_input_error.hpp
@@ -0,0 +1,62 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2007, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 illegal_input_error.hpp
+ * Contains an input exception.
+ */
+
+#ifndef PB_DS_ILLEGAL_INPUT_EX_HPP
+#define PB_DS_ILLEGAL_INPUT_EX_HPP
+
+#include <exception>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    class illegal_input_error : public std::exception
+    { };
+
+    // Substitute for concurrence_error object in the case of -fno-exceptions.
+    inline void
+    __throw_illegal_input_error()
+    {
+#if __EXCEPTIONS
+      throw illegal_input_error();
+#else
+      __builtin_abort();
+#endif
+    }
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_ILLEGAL_INPUT_EX_HPP
diff --git a/libstdc++-v3/testsuite/util/io/prog_bar.cc b/libstdc++-v3/testsuite/util/io/prog_bar.cc
new file mode 100644
index 000000000..9b73298e0
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/io/prog_bar.cc
@@ -0,0 +1,79 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 prog_bar.cpp
+ * Contains a progress bar - idea taken from boost::timer by Beman Dawes.
+ */
+
+#include <util/io/prog_bar.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    prog_bar::
+    prog_bar(size_t max, std::ostream& r_os, bool display/*= true*/) :
+      m_cur(0),
+      m_max(max),
+      m_cur_disp(0),
+      m_r_os(r_os),
+      m_display(display)
+    {
+      if (m_display == false)
+        return;
+
+      for (std::size_t i = 0; i < num_disp; ++i)
+        m_r_os << "-";
+
+      m_r_os << std::endl;
+    }
+
+    void
+    prog_bar::
+    inc()
+    {
+      ++m_cur;
+
+      if (m_display == false)
+        return;
+
+      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;
+	}
+    }
+
+  } // namespace test
+
+} // namespace __gnu_pbds
diff --git a/libstdc++-v3/testsuite/util/io/prog_bar.hpp b/libstdc++-v3/testsuite/util/io/prog_bar.hpp
new file mode 100644
index 000000000..0d4b44853
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/io/prog_bar.hpp
@@ -0,0 +1,86 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 prog_bar.hpp
+ * Contains a progress bar - idea taken from boost::timer by Beman Dawes.
+ */
+
+#ifndef PB_DS_PROG_BAR_HPP
+#define PB_DS_PROG_BAR_HPP
+
+#include <limits.h>
+#include <iostream>
+#include <string>
+
+namespace __gnu_pbds
+{
+
+  namespace test
+  {
+
+    /**
+     * Progress bar.
+     * Simplified from part of boost::timer by Beman Dawes.
+     **/
+    class prog_bar
+    {
+    protected:
+      enum{num_disp = 40};
+
+    public:
+      prog_bar(size_t max, std::ostream& r_os, bool display = true);
+
+      void
+      inc();
+
+    private:
+      prog_bar(const prog_bar& );
+
+      prog_bar& 
+      operator=(const prog_bar& );
+
+    private:
+      size_t m_cur;
+      const size_t m_max;
+
+      size_t m_cur_disp;
+
+      std::ostream& m_r_os;
+
+      bool m_display;
+    };
+
+  } // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_PROG_BAR_HPP
diff --git a/libstdc++-v3/testsuite/util/io/text_populate.hpp b/libstdc++-v3/testsuite/util/io/text_populate.hpp
new file mode 100644
index 000000000..97731dd9f
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/io/text_populate.hpp
@@ -0,0 +1,153 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 text_populate.hpp
+ * Contains a function for populating a vector with text words from
+ *    a file.
+ */
+
+#ifndef PB_DS_TEXT_POPULATE_HPP
+#define PB_DS_TEXT_POPULATE_HPP
+
+#include <io/illegal_input_error.hpp>
+#include <set>
+#include <fstream>
+#include <string>
+#include <iostream>
+
+namespace __gnu_pbds
+{
+
+  namespace test
+  {
+
+    template<typename Vec>
+    void
+    text_populate(const std::string& r_f_name, Vec& r_a_txt)
+    {
+      const size_t size = r_a_txt.size();
+
+      try
+	{
+	  std::ifstream f(r_f_name.c_str());
+
+	  if (!f.good())
+	    {
+	      std::cerr << "Cannot open file " << r_f_name.c_str() <<
+                std::endl;
+
+	      throw __gnu_pbds::test::illegal_input_error();
+	    }
+
+	  size_t i = 0;
+
+	  while (f.good()&&  i < size)
+	    {
+	      f >> r_a_txt[i].first;
+	      r_a_txt[i].second = 0;
+
+	      ++i;
+	    }
+
+	  if (i < size)
+	    {
+	      std::cerr << "Read only " << static_cast<unsigned long>(i) <<
+                " words" << std::endl;
+
+	      throw __gnu_pbds::test::illegal_input_error();
+	    }
+	}
+      catch(...)
+	{
+	  std::cerr << "Error reading from file" << std::endl;
+
+	  throw;
+	}
+    }
+
+    template<typename Vec>
+    void
+    distinct_text_populate(const std::string& r_f_name, Vec& r_a_txt)
+    {
+      const size_t size = r_a_txt.size();
+
+      try
+	{
+	  std::ifstream f(r_f_name.c_str());
+
+	  if (!f.good())
+	    {
+	      std::cerr << "Cannot open file " << r_f_name.c_str() <<
+                std::endl;
+
+	      throw __gnu_pbds::test::illegal_input_error();
+	    }
+
+	  typedef std::set< typename Vec::value_type::first_type> set_t;
+
+	  set_t s;
+
+	  while (f.good()&&  s.size() < size)
+	    {
+	      typename Vec::value_type::first_type v;
+
+	      f >> v;
+
+	      if (s.find(v) == s.end())
+		{
+		  r_a_txt[s.size()] = std::make_pair(v, 0);
+
+		  s.insert(v);
+		}
+	    }
+
+	  if (s.size() < size)
+	    {
+	      std::cerr << "Read only " << static_cast<unsigned long>(s.size()) <<
+                " words" << std::endl;
+
+	      throw __gnu_pbds::test::illegal_input_error();
+	    }
+	}
+      catch(...)
+	{
+	  std::cerr << "Error reading from file" << std::endl;
+
+	  throw;
+	}
+    }
+
+  } // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_TEXT_POPULATE_HPP
diff --git a/libstdc++-v3/testsuite/util/io/verified_cmd_line_input.cc b/libstdc++-v3/testsuite/util/io/verified_cmd_line_input.cc
new file mode 100644
index 000000000..3f94a2759
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/io/verified_cmd_line_input.cc
@@ -0,0 +1,106 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2007, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 verified_cmd_line_input.cpp
+ * Contains definitions for tests - verified command line input.
+ */
+
+#include <util/io/verified_cmd_line_input.hpp>
+#include <limits.h>
+#include <utility>
+#include <stdlib.h>
+#include <bits/functexcept.h>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    void
+    verify_argc(size_t given, size_t required)
+    {
+      if (given != required)
+	__throw_illegal_input_error();
+    }
+
+    void
+    verify_prob(double prob)
+    {
+      if (prob < 0 || prob > 1)
+        __throw_illegal_input_error();
+    }
+
+    std::string
+    get_cmd_line_str(int argc, char* a_p_argv[], int argn)
+    {
+      if (argc <= argn)
+        __throw_illegal_input_error();
+      const std::string ret(a_p_argv[argn]);
+      return ret;
+    }
+
+    double
+    get_cmd_line_prob(int argc, char* a_p_argv[], int argn)
+    {
+      if (argc <= argn)
+        __throw_illegal_input_error();
+      const double ret = ::atof(a_p_argv[argn]);
+      verify_prob(ret);
+      return ret;
+    }
+
+    size_t
+    get_cmd_line_size(int argc, char* a_p_argv[], int argn)
+    {
+      if (argc <= argn)
+        __throw_illegal_input_error();
+      const size_t ret = static_cast<size_t>(::atoi(a_p_argv[argn]));
+      return ret;
+    }
+
+    bool
+    get_cmd_line_bool(int argc, char* a_p_argv[], int argn)
+    {
+      if (argc <= argn)
+        __throw_illegal_input_error();
+
+      const std::string opt(a_p_argv[argn]);
+      if (opt.size() != 1)
+        __throw_illegal_input_error();
+      if (opt[0] == 't')
+        return true;
+      if (opt[0] == 'f')
+        return false;
+      __throw_illegal_input_error();
+      return false;
+    }
+  } // namespace test
+} // namespace __gnu_pbds
diff --git a/libstdc++-v3/testsuite/util/io/verified_cmd_line_input.hpp b/libstdc++-v3/testsuite/util/io/verified_cmd_line_input.hpp
new file mode 100644
index 000000000..29651f7ae
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/io/verified_cmd_line_input.hpp
@@ -0,0 +1,67 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 verified_cmd_line_input.hpp
+ * Contains definitions for tests - verified command line input.
+ */
+
+#ifndef PB_DS_VERIFIED_CMD_LINE_INPUT_HPP
+#define PB_DS_VERIFIED_CMD_LINE_INPUT_HPP
+
+#include <io/illegal_input_error.hpp>
+#include <string>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    void
+    verify_argc(size_t given, size_t required);
+
+    void
+    verify_prob(double prob);
+
+    std::string
+    get_cmd_line_str(int argc, char* a_p_argv[], int argn);
+
+    double
+    get_cmd_line_prob(int argc, char* a_p_argv[], int argn);
+
+    size_t
+    get_cmd_line_size(int argc, char* a_p_argv[], int argn);
+
+    bool
+    get_cmd_line_bool(int argc, char* a_p_argv[], int argn);
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_VERIFIED_CMD_LINE_INPUT_HPP
diff --git a/libstdc++-v3/testsuite/util/io/xml.hpp b/libstdc++-v3/testsuite/util/io/xml.hpp
new file mode 100644
index 000000000..d945a3bef
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/io/xml.hpp
@@ -0,0 +1,121 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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.hpp
+ * Contains some xml utilities.
+ */
+
+#ifndef PB_DS_XML_HPP
+#define PB_DS_XML_HPP
+
+#include <string>
+#include <sstream>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      std::string
+      make_xml_name_start_tag(std::string name)
+      { return ("<" + name); }
+
+      template<typename V>
+      std::string
+      make_xml_attrib_val(std::string attrib, const V val)
+      {
+	std::ostringstream sstrm;
+	sstrm << " " << attrib << " = \"" << val << "\"";
+	return (sstrm.str());
+      }
+
+      std::string
+      make_xml_name_start_tag_end_delimiter()
+      { return (">\n"); }
+
+      std::string
+      make_xml_name_end_tag(std::string name)
+      { return ("</" + name + ">\n"); }
+    } // namespace detail
+
+    std::string
+    make_xml_tag(const std::string name,
+		 const std::string data = std::string(""))
+    {
+      std::ostringstream sstrm;
+      sstrm << detail::make_xml_name_start_tag(name);
+      sstrm << detail::make_xml_name_start_tag_end_delimiter();
+      sstrm << data;
+      sstrm << detail::make_xml_name_end_tag(name);
+      return sstrm.str();
+    }
+
+    template<typename Val0>
+    std::string
+    make_xml_tag(const std::string name,
+		 const std::string attrib0,
+		 const Val0 val0,
+		 const std::string data = std::string(""))
+    {
+      std::ostringstream sstrm;
+
+      sstrm << detail::make_xml_name_start_tag(name);
+      sstrm << detail::make_xml_attrib_val(attrib0, val0);
+      sstrm << detail::make_xml_name_start_tag_end_delimiter();
+      sstrm << data;
+      sstrm << detail::make_xml_name_end_tag(name);
+      return sstrm.str();
+    }
+
+    template<typename Val0, typename Val1>
+    std::string
+    make_xml_tag(const std::string name,
+		 const std::string attrib0,
+		 const Val0 val0,
+		 const std::string attrib1,
+		 const Val1 val1,
+		 const std::string data = std::string(""))
+    {
+      std::ostringstream sstrm;
+      sstrm << detail::make_xml_name_start_tag(name);
+      sstrm << detail::make_xml_attrib_val(attrib0, val0);
+      sstrm << detail::make_xml_attrib_val(attrib1, val1);
+      sstrm << detail::make_xml_name_start_tag_end_delimiter();
+      sstrm << data;
+      sstrm << detail::make_xml_name_end_tag(name);
+      return sstrm.str();
+    }
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_XML_HPP
diff --git a/libstdc++-v3/testsuite/util/io/xml_test_formatter.hpp b/libstdc++-v3/testsuite/util/io/xml_test_formatter.hpp
new file mode 100644
index 000000000..b06d3e49d
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/io/xml_test_formatter.hpp
@@ -0,0 +1,78 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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_test_formatter.hpp
+ * Contains an XML formatter for tests.
+ */
+
+#ifndef PB_DS_XML_TEST_FORMATTER_HPP
+#define PB_DS_XML_TEST_FORMATTER_HPP
+
+#include <string>
+#include <iostream>
+#include <io/xml.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    struct xml_test_formatter
+    {
+      xml_test_formatter()
+      {
+	std::cout << "<?xml version = \"1.0\"?>" << std::endl;
+	std::cout << "<test>" << std::endl;
+      }
+
+      virtual
+      ~xml_test_formatter()
+      { std::cout << "</test>" << std::endl; }
+    };
+
+    struct xml_result_set_formatter
+    {
+      xml_result_set_formatter(const std::string& name, const std::string& desc)
+      {
+	std::cout << detail::make_xml_name_start_tag("cntnr");
+	std::cout << detail::make_xml_attrib_val("name", name);
+	std::cout << detail::make_xml_name_start_tag_end_delimiter();	
+	std::cout << make_xml_tag("desc", desc);
+      }
+
+      virtual
+      ~xml_result_set_formatter()
+      { std::cout << "</cntnr>" << std::endl; }
+    };
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_XML_TEST_FORMATTER_HPP
diff --git a/libstdc++-v3/testsuite/util/native_type/native_hash_map.hpp b/libstdc++-v3/testsuite/util/native_type/native_hash_map.hpp
new file mode 100644
index 000000000..6fa3667f3
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/native_type/native_hash_map.hpp
@@ -0,0 +1,103 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2007, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 native_hash_map.hpp
+ * Contains an adapter to TR1 unordered containers.
+ */
+
+#ifndef PB_DS_NATIVE_HASH_MAP_HPP
+#define PB_DS_NATIVE_HASH_MAP_HPP
+
+#include <string>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/standard_policies.hpp>
+#include <native_type/native_hash_tag.hpp>
+#include <io/xml.hpp>
+#include <tr1/unordered_map>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+#define PB_DS_BASE_C_DEC \
+    std::tr1::__unordered_map<Key, Data, Hash_Fn, Eq_Fn, \
+    typename Allocator::template rebind<std::pair<const Key, Data> >::other, Cache_Hash>
+
+    template<typename Key,
+	     typename Data,
+	     size_t Init_Size = 8,
+	     typename Hash_Fn = typename __gnu_pbds::detail::default_hash_fn<Key>::type,
+	     typename Eq_Fn = std::equal_to<Key>,
+	     typename Less_Fn = std::less<Key>,
+	     typename Allocator = std::allocator<char>, bool Cache_Hash = false
+	     >
+    class native_hash_map : public PB_DS_BASE_C_DEC
+    {
+    private:
+      typedef PB_DS_BASE_C_DEC base_type;
+
+    public:
+      typedef native_hash_tag container_category;
+
+    public:
+      native_hash_map() : base_type(Init_Size) { }
+
+      template<typename It>
+      native_hash_map(It f, It l) : base_type(f, l) { }
+
+      static std::string
+      name()
+      {
+        return std::string("n_hash_map_") 
+               + (Cache_Hash ? std::string("cah") : std::string("ncah"));
+      }
+
+      static std::string
+      desc()
+      {
+        const std::string cache_hash_desc =
+	make_xml_tag("cache_hash_code",
+		     "value",
+		    (Cache_Hash ? std::string("true") : std::string("false")));
+
+        return make_xml_tag("type", "value", "std_tr1_unordered_map", 
+			    cache_hash_desc);
+      }
+    };
+
+#undef PB_DS_BASE_C_DEC
+
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
+
diff --git a/libstdc++-v3/testsuite/util/native_type/native_hash_multimap.hpp b/libstdc++-v3/testsuite/util/native_type/native_hash_multimap.hpp
new file mode 100644
index 000000000..8273edf36
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/native_type/native_hash_multimap.hpp
@@ -0,0 +1,146 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2007, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 native_hash_multimap.hpp
+ * Contains an adapter to TR1 unordered containers.
+ */
+
+#ifndef PB_DS_NATIVE_HASH_MULTIMAP_HPP
+#define PB_DS_NATIVE_HASH_MULTIMAP_HPP
+
+#include <string>
+#include <tr1/unordered_map>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/standard_policies.hpp>
+#include <native_type/native_hash_tag.hpp>
+#include <io/xml.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+#define PB_DS_BASE_C_DEC \
+    std::tr1::unordered_multimap<Key, Data, Hash_Fn, Eq_Fn, Allocator>
+
+    template<typename Key,
+	     typename Data,
+	     size_t Init_Size = 8,
+       class Hash_Fn = typename __gnu_pbds::detail::default_hash_fn<Key>::type,
+	     class Eq_Fn = std::equal_to<Key>,
+	     class Less_Fn = std::less<Key>,
+	     class Allocator = std::allocator<char> >
+    class native_hash_multimap : public PB_DS_BASE_C_DEC
+    {
+    private:
+      typedef PB_DS_BASE_C_DEC 			base_type;
+      typedef std::pair<Key, Data> 		pair_type;
+
+    public:
+      typedef native_hash_tag 			container_category;
+      typedef Allocator 			allocator;
+      typedef typename base_type::iterator 	iterator;
+      typedef typename base_type::const_iterator const_iterator;
+
+      typedef
+      typename allocator::template rebind<pair_type>::other::const_reference
+      const_reference;
+
+      native_hash_multimap() : base_type(Init_Size)
+      { }
+
+      template<typename It>
+      native_hash_multimap(It f, It l) : base_type(f, l)
+      { }
+
+      inline void
+      insert(const_reference r_val)
+      {
+        typedef std::pair<iterator, iterator> eq_range_t;
+        eq_range_t f = base_type::equal_range(r_val.first);
+
+        iterator it = f.first;
+        while (it != f.second)
+	  {
+            if (it->second == r_val.second)
+	      return;
+            ++it;
+	  }
+        base_type::insert(r_val);
+      }
+
+      inline iterator
+      find(const_reference r_val)
+      {
+        typedef std::pair<iterator, iterator> eq_range_t;
+        eq_range_t f = base_type::equal_range(r_val.first);
+
+        iterator it = f.first;
+        while (it != f.second)
+	  {
+            if (it->second == r_val.second)
+	      return it;
+            ++it;
+	  }
+        return base_type::end();
+      }
+
+      inline const_iterator
+      find(const_reference r_val) const
+      {
+        typedef std::pair<const_iterator, const_iterator> eq_range_t;
+        eq_range_t f = base_type::equal_range(r_val.first);
+
+        const_iterator it = f.first;
+        while (it != f.second)
+	  {
+            if (it->second == r_val.second)
+	      return it;
+            ++it;
+	  }
+        return base_type::end();
+      }
+
+      static std::string
+      name()
+      { return std::string("n_hash_mmap"); }
+
+      static std::string
+      desc()
+      { return make_xml_tag("type", "value", "__gnucxx_hash_multimap"); }
+    };
+
+#undef PB_DS_BASE_C_DEC
+
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/libstdc++-v3/testsuite/util/native_type/native_hash_set.hpp b/libstdc++-v3/testsuite/util/native_type/native_hash_set.hpp
new file mode 100644
index 000000000..d3f459624
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/native_type/native_hash_set.hpp
@@ -0,0 +1,125 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2007, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 native_hash_set.hpp
+ * Contains an adapter to TR1 unordered containers.
+ */
+
+#ifndef PB_DS_NATIVE_HASH_SET_HPP
+#define PB_DS_NATIVE_HASH_SET_HPP
+
+#include <string>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/standard_policies.hpp>
+#include <native_type/native_hash_tag.hpp>
+#include <io/xml.hpp>
+#include <tr1/unordered_set>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+#define PB_DS_BASE_C_DEC \
+    std::tr1::__unordered_set<Key, Hash_Fn, Eq_Fn, \
+    typename Allocator::template rebind<Key>::other, Cache_Hash>
+
+    template<typename Key,
+	     size_t Init_Size = 8,
+         typename Hash_Fn = typename __gnu_pbds::detail::default_hash_fn<Key>::type,
+	     typename Eq_Fn = std::equal_to<Key>,
+	     typename Less_Fn = std::less<Key>,
+	     typename Allocator = std::allocator<char>, bool Cache_Hash = false
+	     >
+    class native_hash_set : public PB_DS_BASE_C_DEC
+    {
+    private:
+      typedef PB_DS_BASE_C_DEC base_type;
+
+    public:
+      typedef native_hash_tag container_category;
+
+      native_hash_set() : base_type(Init_Size) { }
+
+      template<typename It>
+      native_hash_set(It f, It l) : base_type(f, l) { }
+
+      template<typename Pred>
+      inline size_t
+      erase_if(Pred pred)
+      {
+        size_t ersd = 0;
+        bool done = false;
+        while (!done)
+	  {
+            typename base_type::iterator b_it = base_type::begin();
+            typename base_type::iterator e_it = base_type::end();
+            done = true;
+            while (b_it != e_it)
+	      {
+                if (pred(*b_it))
+		  {
+                    ++ersd;
+                    done = false;
+                    base_type::erase(*b_it);
+                    b_it = e_it;
+		  }
+                else
+		  ++b_it;
+	      }
+	  }
+        return ersd;
+      }
+
+      static std::string
+      name()
+      {
+        return std::string("n_hash_set_") 
+	       + (Cache_Hash ? std::string("cah") : std::string("ncah"));
+      }
+
+      static std::string
+      desc()
+      {
+        const std::string cache_hash_desc =
+	make_xml_tag("cache_hash_code", "value",
+		     Cache_Hash ? std::string("true") : std::string("false"));
+
+        return make_xml_tag("type", "value", "std_tr1_unordered_set", 
+			    cache_hash_desc);
+      }
+    };
+
+#undef PB_DS_BASE_C_DEC
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif
diff --git a/libstdc++-v3/testsuite/util/native_type/native_hash_tag.hpp b/libstdc++-v3/testsuite/util/native_type/native_hash_tag.hpp
new file mode 100644
index 000000000..3ee6c0efa
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/native_type/native_hash_tag.hpp
@@ -0,0 +1,48 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 native_hash_tag.hpp
+ * Contains a tag for native hash-based containers
+ */
+
+#ifndef PB_DS_NATIVE_HASH_DS_TAG_HPP
+#define PB_DS_NATIVE_HASH_DS_TAG_HPP
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    struct native_hash_tag { };
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/libstdc++-v3/testsuite/util/native_type/native_map.hpp b/libstdc++-v3/testsuite/util/native_type/native_map.hpp
new file mode 100644
index 000000000..29170cae8
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/native_type/native_map.hpp
@@ -0,0 +1,87 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 native_map.hpp
+ * Contains an adapter to std::map
+ */
+
+#ifndef PB_DS_NATIVE_MAP_HPP
+#define PB_DS_NATIVE_MAP_HPP
+
+#include <map>
+#include <string>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/standard_policies.hpp>
+#include <native_type/native_tree_tag.hpp>
+#include <io/xml.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+#define PB_DS_BASE_C_DEC \
+    std::map<Key, Data, Cmp_Fn,	\
+typename Allocator::template rebind<std::pair<const Key, Data > >::other >
+
+    template<typename Key, typename Data, class Cmp_Fn = std::less<Key>,
+	     class Allocator = std::allocator<char> >
+    class native_map : public PB_DS_BASE_C_DEC
+    {
+    private:
+      typedef PB_DS_BASE_C_DEC base_type;
+
+    public:
+      typedef native_tree_tag container_category;
+
+      native_map() : base_type()
+      { }
+
+      template<typename It>
+      native_map(It f, It l) : base_type(f, l)
+      { }
+
+      static std::string
+      name()
+      { return std::string("n_map"); }
+
+      static std::string
+      desc()
+      { return make_xml_tag("type", "value", "std_map"); }
+    };
+
+#undef PB_DS_BASE_C_DEC
+
+  } // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_NATIVE_MAP_HPP
diff --git a/libstdc++-v3/testsuite/util/native_type/native_multimap.hpp b/libstdc++-v3/testsuite/util/native_type/native_multimap.hpp
new file mode 100644
index 000000000..4bda5562d
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/native_type/native_multimap.hpp
@@ -0,0 +1,142 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 native_multimap.hpp
+ * Contains an adapter to std::multimap
+ */
+
+#ifndef PB_DS_NATIVE_MULTIMAP_HPP
+#define PB_DS_NATIVE_MULTIMAP_HPP
+
+#include <map>
+#include <string>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <native_type/native_tree_tag.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+#define PB_DS_BASE_C_DEC \
+    std::multimap<Key, Data, Less_Fn, \
+      typename Allocator::template rebind<std::pair<const Key, Data> >::other>
+
+    template<typename Key, typename Data, class Less_Fn = std::less<Key>,
+	     class Allocator = std::allocator<char> >
+    class native_multimap : public PB_DS_BASE_C_DEC
+    {
+    private:
+      typedef PB_DS_BASE_C_DEC base_type;
+
+    public:
+      typedef native_tree_tag container_category;
+
+      typedef Allocator allocator;
+
+      typedef
+      typename Allocator::template rebind<
+	std::pair<Key, Data> >::other::const_reference
+      const_reference;
+
+      typedef typename base_type::iterator iterator;
+      typedef typename base_type::const_iterator const_iterator;
+
+      native_multimap()  { }
+
+      template<typename It>
+      native_multimap(It f, It l) : base_type(f, l)
+      { }
+
+      inline void
+      insert(const_reference r_val)
+      {
+        typedef std::pair<iterator, iterator> eq_range_t;
+        eq_range_t f = base_type::equal_range(r_val.first);
+
+        iterator it = f.first;
+        while (it != f.second)
+	  {
+            if (it->second == r_val.second)
+	      return;
+            ++it;
+	  }
+        base_type::insert(r_val);
+      }
+
+      inline iterator
+      find(const_reference r_val)
+      {
+        typedef std::pair<iterator, iterator> eq_range_t;
+        eq_range_t f = base_type::equal_range(r_val.first);
+
+        iterator it = f.first;
+        while (it != f.second)
+	  {
+            if (it->second == r_val.second)
+	      return it;
+            ++it;
+	  }
+
+        return base_type::end();
+      }
+
+      inline const_iterator
+      find(const_reference r_val) const
+      {
+        typedef std::pair<const_iterator, const_iterator> eq_range_t;
+        eq_range_t f = base_type::equal_range(r_val.first);
+
+        const_iterator it = f.first;
+        while (it != f.second)
+	  {
+            if (it->second == r_val.second)
+	      return it;
+            ++it;
+	  }
+        return base_type::end();
+      }
+      
+      static std::string
+      name()
+      { return std::string("n_mmap"); }
+
+      static std::string
+      desc()
+      { return make_xml_tag("type", "value", "std_multimap"); }
+    };
+
+#undef PB_DS_BASE_C_DEC
+} // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_NATIVE_MULTIMAP_HPP
diff --git a/libstdc++-v3/testsuite/util/native_type/native_priority_queue.hpp b/libstdc++-v3/testsuite/util/native_type/native_priority_queue.hpp
new file mode 100644
index 000000000..4367fca30
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/native_type/native_priority_queue.hpp
@@ -0,0 +1,224 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 native_priority_queue.hpp
+ * Contains an adapter to Dinkumware/SGI tree tables
+ */
+
+#ifndef PB_DS_NATIVE_PRIORITY_QUEUE_HPP
+#define PB_DS_NATIVE_PRIORITY_QUEUE_HPP
+
+#include <string>
+#include <vector>
+#include <queue>
+#include <deque>
+#include <ext/pb_ds/detail/standard_policies.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <io/xml.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      template<typename Value_Type, bool Vector, typename Allocator>
+      struct base_seq
+      {
+      private:
+	typedef typename Allocator::template rebind<Value_Type> value_rebind;
+
+      public:
+	typedef std::vector<Value_Type, typename value_rebind::other> type;
+      };
+
+      template<typename Value_Type, typename Allocator>
+      struct base_seq<Value_Type, false, Allocator>
+      {
+      private:
+	typedef typename Allocator::template rebind<Value_Type> value_rebind;
+
+      public:
+	typedef std::deque<Value_Type, typename value_rebind::other> type;
+      };
+    } // namespace detail
+
+    struct native_pq_tag
+    { };
+
+#define PB_DS_CLASS_C_DEC \
+    native_priority_queue<Value_Type, Vector, Cmp_Fn, Allocator>
+
+#define PB_DS_BASE_C_DEC \
+    std::priority_queue<Value_Type, typename detail::base_seq<Value_Type, Vector, Allocator>::type, Cmp_Fn>
+
+    template<typename Value_Type,
+	     bool Vector,
+	     typename Cmp_Fn = std::less<Value_Type>,
+	     typename Allocator = std::allocator<char> >
+    class native_priority_queue : public PB_DS_BASE_C_DEC
+    {
+    private:
+      typedef PB_DS_BASE_C_DEC base_type;
+      typedef typename Allocator::template rebind<Value_Type> value_rebind;
+
+    public:
+      typedef Value_Type value_type;
+      typedef typename value_rebind::other::const_reference const_reference;
+      typedef native_pq_tag container_category;
+      typedef Cmp_Fn cmp_fn;
+
+      native_priority_queue() : base_type()
+      { }
+
+      template<typename It>
+      native_priority_queue(It f, It l) : base_type(f, l)
+      { }
+
+      static std::string
+      name()
+      {
+        if (Vector)
+	  return ("n_pq_vector");
+        return ("n_pq_deque");
+      }
+
+      static std::string
+      desc()
+      {
+        if (Vector)
+	  return make_xml_tag("type", "value", "std::priority_queue_vector");
+        return make_xml_tag("type", "value", "std::priority_queue_deque");
+      }
+
+      void
+      clear()
+      { *static_cast<base_type*>(this) = base_type(); }
+
+      void
+      erase(const_reference r_val)
+      {
+        base_type tmp;
+        Cmp_Fn cmp;
+
+        while (cmp(base_type::top(), r_val) || cmp(r_val, base_type::top()))
+	  {
+            tmp.push(base_type::top());
+            base_type::pop();
+	  }
+
+        if (!base_type::empty())
+	  {
+            base_type::pop();
+            while (!base_type::empty())
+	      {
+                tmp.push(base_type::top());
+                base_type::pop();
+	      }
+	  }
+	*static_cast<base_type* >(this) = tmp;
+      }
+
+      template<typename Pred>
+      size_t
+      erase_if(Pred pred)
+      {
+        base_type tmp;
+        std::size_t ersd = 0;
+        while (!base_type::empty())
+	  {
+            if (!pred(base_type::top()))
+	      tmp.push(base_type::top());
+            else
+	      ++ersd;
+            base_type::pop();
+	  }
+
+	*static_cast<base_type*>(this) = tmp;
+        return ersd;
+      }
+
+      template<typename Pred>
+      void
+      split(Pred pred, PB_DS_CLASS_C_DEC& other)
+      {
+        base_type tmp;
+        other.clear();
+        while (!base_type::empty())
+	  {
+            if (!pred(base_type::top()))
+	      tmp.push(base_type::top());
+            else
+	      other.push(base_type::top());
+            base_type::pop();
+	  }
+	*static_cast<base_type*>(this) = tmp;
+      }
+
+      void
+      modify(const_reference r_old, const_reference r_new)
+      {
+        erase(r_old);
+        push(r_new);
+      }
+
+      void
+      join(PB_DS_CLASS_C_DEC& other)
+      {
+        std::vector<value_type> a_tmp;
+        while (!base_type::empty())
+	  {
+            a_tmp.push_back(base_type::top());
+            base_type::pop();
+	  }
+
+        while (!other.empty())
+	  {
+            a_tmp.push_back(other.top());
+            other.pop();
+	  }
+
+	*static_cast<base_type*>(this) = base_type(a_tmp.begin(), a_tmp.end());
+      }
+
+      Cmp_Fn
+      get_cmp_fn() const
+      { return Cmp_Fn(); }
+    };
+
+#undef PB_DS_BASE_C_DEC
+#undef PB_DS_CLASS_C_DEC
+
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/libstdc++-v3/testsuite/util/native_type/native_set.hpp b/libstdc++-v3/testsuite/util/native_type/native_set.hpp
new file mode 100644
index 000000000..c9f448bf1
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/native_type/native_set.hpp
@@ -0,0 +1,87 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 native_set.hpp
+ * Contains an adapter to std::set
+ */
+
+#ifndef PB_DS_NATIVE_SET_HPP
+#define PB_DS_NATIVE_SET_HPP
+
+#include <string>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <ext/pb_ds/detail/standard_policies.hpp>
+#include <native_type/native_tree_tag.hpp>
+#include <io/xml.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+#define PB_DS_BASE_C_DEC \
+    std::set<Key, Cmp_Fn, typename Allocator::template rebind<Key>::other>
+
+    template<typename Key, class Cmp_Fn = std::less<Key>,
+	     class Allocator = std::allocator<char> >
+    class native_set : public PB_DS_BASE_C_DEC
+    {
+    private:
+      typedef PB_DS_BASE_C_DEC 			 base_type;
+
+    public:
+      typedef native_tree_tag 			 container_category;
+      typedef typename base_type::const_iterator const_iterator;
+
+      native_set() : base_type()
+      { }
+
+      template<typename It>
+      native_set(It f,  It l) : base_type(f, l)
+      { }
+
+      native_set(const_iterator f,  const_iterator l) : base_type(f, l)
+      { }
+
+      static std::string
+      name()
+      { return std::string("n_set"); }
+
+      static std::string
+      desc()
+      { return make_xml_tag("type", "value", "std_set"); }
+    };
+
+#undef PB_DS_BASE_C_DEC
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_NATIVE_SET_HPP
diff --git a/libstdc++-v3/testsuite/util/native_type/native_tree_tag.hpp b/libstdc++-v3/testsuite/util/native_type/native_tree_tag.hpp
new file mode 100644
index 000000000..60127c164
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/native_type/native_tree_tag.hpp
@@ -0,0 +1,49 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 native_tree_tag.hpp
+ * Contains a tag for native tree-based containers
+ */
+
+#ifndef PB_DS_NATIVE_TREE_DS_TAG_HPP
+#define PB_DS_NATIVE_TREE_DS_TAG_HPP
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    struct native_tree_tag
+    { };
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/libstdc++-v3/testsuite/util/performance/assoc/mem_usage/erase_test.hpp b/libstdc++-v3/testsuite/util/performance/assoc/mem_usage/erase_test.hpp
new file mode 100644
index 000000000..6ad797a66
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/assoc/mem_usage/erase_test.hpp
@@ -0,0 +1,109 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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_test.hpp
+ * Contains a generic erase test.
+ */
+
+#ifndef PB_DS_ERASE_TEST_HPP
+#define PB_DS_ERASE_TEST_HPP
+
+#include <iterator>
+#include <testsuite_allocator.h>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <performance/io/xml_formatter.hpp>
+#include <common_type/assoc/string_form.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    template<typename It>
+    class erase_test
+    {
+    public:
+      erase_test(It ins_b, size_t ins_vn, size_t ins_vs, size_t ins_vm)
+      :	m_ins_b(ins_b), m_ins_vn(ins_vn), m_ins_vs(ins_vs), m_ins_vm(ins_vm)
+      { }
+
+      template<typename Cntnr>
+        void
+        operator()(Cntnr);
+
+    private:
+      erase_test(const erase_test&);
+
+      const It 		m_ins_b;
+      const size_t 	m_ins_vn;
+      const size_t 	m_ins_vs;
+      const size_t 	m_ins_vm;
+    };
+
+    template<typename It>
+    template<typename Cntnr>
+    void
+    erase_test<It>::
+    operator()(Cntnr)
+    {
+      typedef string_form<Cntnr> sform_type;
+      typedef xml_result_set_performance_formatter formatter_type;
+      formatter_type res_set_fmt(sform_type::name(), sform_type::desc());
+
+      for (size_t i = 0; m_ins_vn + i * m_ins_vs < m_ins_vm; ++i)
+	{
+	  const size_t ins_size = m_ins_vn + i * m_ins_vs;
+
+	  It ins_it_b = m_ins_b;
+	  It ins_it_e = m_ins_b;
+	  std::advance(ins_it_e, ins_size);
+
+	  typedef __gnu_test::tracker_allocator_counter counter_type;
+	  __gnu_test::tracker_allocator<char> alloc;
+	  const size_t init_mem = counter_type::get_allocation_count() 
+	                          - counter_type::get_deallocation_count();
+	  Cntnr cntnr(ins_it_b, ins_it_e);
+
+	  while (cntnr.size() > 1)
+            cntnr.erase(*cntnr.begin());
+
+	  const size_t final_mem = counter_type::get_allocation_count() 
+	                         - counter_type::get_deallocation_count();
+	  assert(final_mem > init_mem);
+	  const size_t delta_mem = final_mem - init_mem;
+	  res_set_fmt.add_res(ins_size, static_cast<double>(delta_mem));
+	}
+    }
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif
+
diff --git a/libstdc++-v3/testsuite/util/performance/assoc/mem_usage/multimap_insert_test.hpp b/libstdc++-v3/testsuite/util/performance/assoc/mem_usage/multimap_insert_test.hpp
new file mode 100644
index 000000000..110dd923f
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/assoc/mem_usage/multimap_insert_test.hpp
@@ -0,0 +1,144 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 multimap_insert_test.hpp
+ * Contains a generic multimap_insert_test test.
+ */
+
+#ifndef PB_DS_MULTIMAP_INSERT_TEST_HPP
+#define PB_DS_MULTIMAP_INSERT_TEST_HPP
+
+#include <iterator>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <testsuite_allocator.h>
+#include <performance/io/xml_formatter.hpp>
+#include <common_type/assoc/string_form.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    template<typename It, bool Native>
+    class multimap_insert_test
+    {
+    public:
+      multimap_insert_test(It b, size_t ins_vn, size_t ins_vs, size_t ins_vm):
+      m_ins_b(b), m_ins_vn(ins_vn), m_ins_vs(ins_vs), m_ins_vm(ins_vm)
+      { }
+
+      template<typename Cntnr>
+      void
+      operator()(Cntnr);
+
+    private:
+      multimap_insert_test(const multimap_insert_test&);
+
+      template<typename Cntnr>
+      size_t
+      insert(Cntnr, It ins_it_b, It ins_it_e, __gnu_pbds::detail::true_type);
+
+      template<typename Cntnr>
+      size_t
+      insert(Cntnr, It ins_it_b, It ins_it_e, __gnu_pbds::detail::false_type);
+
+      const It m_ins_b;
+      const size_t m_ins_vn;
+      const size_t m_ins_vs;
+      const size_t m_ins_vm;
+    };
+
+    template<typename It, bool Native>
+    template<typename Cntnr>
+    void
+    multimap_insert_test<It, Native>::
+    operator()(Cntnr)
+    {
+      typedef xml_result_set_performance_formatter formatter_type;
+      formatter_type res_set_fmt(string_form<Cntnr>::name(),
+				 string_form<Cntnr>::desc());
+
+      for (size_t i = 0; m_ins_vn + i * m_ins_vs < m_ins_vm; ++i)
+	{
+	  const size_t ins_size = m_ins_vn + i * m_ins_vs;
+	  It ins_it_b = m_ins_b;
+	  It ins_it_e = m_ins_b;
+	  std::advance(ins_it_e, ins_size);
+
+	  const size_t delta_mem = insert(Cntnr(), ins_it_b, ins_it_e,
+					  __gnu_pbds::detail::integral_constant<int,Native>());
+
+	  res_set_fmt.add_res(ins_size, static_cast<double>(delta_mem));
+	}
+    }
+
+    template<typename It, bool Native>
+    template<typename Cntnr>
+    size_t
+    multimap_insert_test<It, Native>::
+    insert(Cntnr, It ins_it_b, It ins_it_e, __gnu_pbds::detail::true_type)
+    {
+      typedef __gnu_test::tracker_allocator_counter counter_type;
+      __gnu_test::tracker_allocator<char> alloc;
+      const size_t init_mem = counter_type::get_allocation_count() 
+	                      - counter_type::get_deallocation_count();
+      Cntnr cntnr;
+      for (It ins_it = ins_it_b; ins_it != ins_it_e; ++ins_it)
+        cntnr.insert((typename Cntnr::const_reference)(*ins_it));
+      const size_t final_mem = counter_type::get_allocation_count() 
+	                       - counter_type::get_deallocation_count();
+      assert(final_mem > init_mem);
+      return (final_mem - init_mem);
+    }
+
+    template<typename It, bool Native>
+    template<typename Cntnr>
+    size_t
+    multimap_insert_test<It, Native>::
+    insert(Cntnr, It ins_it_b, It ins_it_e, __gnu_pbds::detail::false_type)
+    {
+      typedef __gnu_test::tracker_allocator_counter counter_type;
+      __gnu_test::tracker_allocator<char> alloc;
+      const size_t init_mem = counter_type::get_allocation_count() 
+	                      - counter_type::get_deallocation_count();
+      Cntnr cntnr;
+      for (It ins_it = ins_it_b; ins_it != ins_it_e; ++ins_it)
+        cntnr[ins_it->first].insert(ins_it->second);
+      const size_t final_mem =  counter_type::get_allocation_count() 
+	                        - counter_type::get_deallocation_count();
+      assert(final_mem > init_mem);
+      return (final_mem - init_mem);
+    }
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
+
diff --git a/libstdc++-v3/testsuite/util/performance/assoc/multimap_common_type.hpp b/libstdc++-v3/testsuite/util/performance/assoc/multimap_common_type.hpp
new file mode 100644
index 000000000..e31abe106
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/assoc/multimap_common_type.hpp
@@ -0,0 +1,223 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 multimap_common_type.hpp
+ * Contains types for a generic multimap_insert_test test.
+ */
+
+#ifndef PB_DS_MULTIMAP_RANDOM_INT_INSERT_TEST_COMMON_TYPE_HPP
+#define PB_DS_MULTIMAP_RANDOM_INT_INSERT_TEST_COMMON_TYPE_HPP
+
+#include <hash_fn/string_hash_fn.hpp>
+#include <common_type/assoc/common_type.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      struct int_hash : public std::unary_function<int, size_t>
+      {
+	inline size_t
+        operator()(const int i) const
+	{ return (static_cast<size_t>(i)); }
+      };
+
+      template<typename Key, typename Allocator = std::allocator<char> >
+      struct hash_set_tl_t
+      {
+	typedef
+        typename __gnu_pbds::test::hash_common_types<
+	  Key,
+	  __gnu_pbds::null_mapped_type,
+	  int_hash,
+	  std::equal_to<Key>,
+	  Allocator>::performance_min_tl
+        type;
+      };
+
+      template<typename Key, typename Allocator = std::allocator<char> >
+      struct lu_set_tl_t
+      {
+	typedef
+        typename __gnu_pbds::test::lu_common_types<
+	  Key,
+	  __gnu_pbds::null_mapped_type,
+	  std::equal_to<
+	  Key>,
+	  Allocator>::performance_min_tl
+        type;
+      };
+
+      template<typename Key,
+	       class Sec_Tl,
+	       typename Allocator = std::allocator<char> >
+      struct hash_mmap_tl_t
+      {
+      private:
+	typedef
+        typename __gnu_pbds::detail::__conditional_type<
+	__gnu_pbds::detail::is_same<
+	int,
+	Key>::value,
+	int_hash,
+	string_hash_fn>::__type
+        hash_fn_t;
+
+	template<typename Cntnr_T>
+	struct hash_mmap_transform
+	{
+	  typedef
+	  typename __gnu_pbds::test::hash_common_types<
+	    Key,
+	    Cntnr_T,
+	    hash_fn_t,
+	    std::equal_to<
+	    Key>,
+	    Allocator>::performance_min_tl
+	  type;
+	};
+
+      public:
+	typedef
+        typename __gnu_cxx::typelist::flatten<
+	typename __gnu_cxx::typelist::transform<
+	Sec_Tl,
+	hash_mmap_transform>::type>::type
+        type;
+      };
+
+      template<typename Key,
+	       class Sec_Tl,
+	       typename Allocator = std::allocator<char> >
+      struct tree_mmap_tl_t
+      {
+      private:
+	template<typename Cntnr_T>
+	struct tree_mmap_transform
+	{
+	  typedef
+	  typename __gnu_pbds::test::tree_common_types<
+	    Key,
+	    Cntnr_T,
+	    std::less<
+	    Key>,
+	    __gnu_pbds::null_tree_node_update,
+	    Allocator>::performance_min_tl
+	  type;
+	};
+
+      public:
+	typedef
+        typename __gnu_cxx::typelist::flatten<
+	typename __gnu_cxx::typelist::transform<
+	Sec_Tl,
+	tree_mmap_transform>::type>::type
+        type;
+      };
+
+      template<typename Key, typename Mapped, typename Allocator>
+      struct hash_hash_mmap_tl_t
+      {
+      private:
+	typedef typename hash_set_tl_t<Mapped, Allocator>::type sec_tl_t;
+
+      public:
+	typedef typename hash_mmap_tl_t<Key, sec_tl_t, Allocator>::type type;
+      };
+
+      template<typename Key, typename Mapped, typename Allocator>
+      struct tree_hash_mmap_tl_t
+      {
+      private:
+	typedef typename hash_set_tl_t<Mapped, Allocator>::type sec_tl_t;
+
+      public:
+	typedef typename tree_mmap_tl_t<Key, sec_tl_t, Allocator>::type type;
+      };
+
+      template<typename Key, typename Mapped, typename Allocator>
+      struct tree_lu_mmap_tl_t
+      {
+      private:
+	typedef typename lu_set_tl_t<Mapped, Allocator>::type sec_tl_t;
+
+      public:
+	typedef typename tree_mmap_tl_t<Key, sec_tl_t, Allocator>::type type;
+      };
+
+      template<typename Key, typename Mapped, typename Allocator>
+      struct hash_lu_mmap_tl_t
+      {
+      private:
+	typedef typename lu_set_tl_t<Mapped, Allocator>::type sec_tl_t;
+
+      public:
+	typedef typename hash_mmap_tl_t<Key, sec_tl_t, Allocator>::type type;
+      };
+    } // namespace detail
+
+    template<typename Key, typename Mapped, typename Allocator>
+    struct mmap_tl_t
+    {
+    private:
+      typedef
+      typename detail::hash_hash_mmap_tl_t<Key, Mapped, Allocator>::type
+      hh_mmap_tl_t;
+
+      typedef
+      typename detail::hash_lu_mmap_tl_t<Key, Mapped, Allocator>::type
+      hl_mmap_tl_t;
+
+      typedef
+      typename detail::tree_hash_mmap_tl_t<Key, Mapped, Allocator>::type
+      th_mmap_tl_t;
+
+      typedef
+      typename detail::tree_lu_mmap_tl_t<Key, Mapped, Allocator>::type
+      tl_mmap_tl_t;
+
+    public:
+      typedef
+      typename __gnu_cxx::typelist::append<hl_mmap_tl_t,
+      typename __gnu_cxx::typelist::append<hh_mmap_tl_t,
+      typename __gnu_cxx::typelist::append<th_mmap_tl_t,
+      tl_mmap_tl_t>::type>::type>::type
+      type;
+    };
+
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif
+
diff --git a/libstdc++-v3/testsuite/util/performance/assoc/timing/common_type.hpp b/libstdc++-v3/testsuite/util/performance/assoc/timing/common_type.hpp
new file mode 100644
index 000000000..a553afeab
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/assoc/timing/common_type.hpp
@@ -0,0 +1,103 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 for a generic multimap_insert_test test.
+ */
+
+#ifndef PB_DS_MULTIMAP_RANDOM_INT_INSERT_TEST_COMMON_TYPE_HPP
+#define PB_DS_MULTIMAP_RANDOM_INT_INSERT_TEST_COMMON_TYPE_HPP
+
+#include <common_type/assoc/common_type.hpp>
+
+namespace __gnu_pbds
+{
+
+  namespace test
+  {
+
+    typedef
+    __gnu_pbds::test::hash_common_types<
+      int,
+      __gnu_pbds::null_mapped_type>::tl
+    hash_set_tl_t;
+
+    template<typename Cntnr_T>
+    struct hash_mmap_transform
+    {
+      typedef
+      typename __gnu_pbds::test::hash_common_types<
+	int,
+	__gnu_pbds::compound_data_type<
+	Cntnr_T> >::tl
+      type;
+    };
+
+    typedef
+    __gnu_cxx::typelist::flatten<
+      __gnu_cxx::typelist::transform<
+      hash_set_tl_t,
+      hash_mmap_transform>::type>::type
+    hash_mmap_tl_t;
+
+    typedef
+    __gnu_pbds::test::tree_common_types<
+      int,
+      __gnu_pbds::null_mapped_type>::tl
+    tree_set_tl_t;
+
+    template<typename Cntnr_T>
+    struct tree_mmap_transform
+    {
+      typedef
+      typename __gnu_pbds::test::tree_common_types<
+	int,
+	__gnu_pbds::compound_data_type<
+	Cntnr_T> >::tl
+      type;
+    };
+
+    typedef
+    __gnu_cxx::typelist::flatten<
+      __gnu_cxx::typelist::transform<
+      tree_set_tl_t,
+      tree_mmap_transform>::type>::type
+    tree_mmap_tl_t;
+
+    typedef hash_mmap_tl_t mmap_tl_t;
+
+  } // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_MULTIMAP_RANDOM_INT_INSERT_TEST_COMMON_TYPE_HPP
+
diff --git a/libstdc++-v3/testsuite/util/performance/assoc/timing/find_test.hpp b/libstdc++-v3/testsuite/util/performance/assoc/timing/find_test.hpp
new file mode 100644
index 000000000..f53a1273c
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/assoc/timing/find_test.hpp
@@ -0,0 +1,166 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 find_test.hpp
+ * Contains a generic find test.
+ */
+
+#ifndef PB_DS_FIND_TEST_HPP
+#define PB_DS_FIND_TEST_HPP
+
+#include <performance/time/timing_test_base.hpp>
+#include <performance/io/xml_formatter.hpp>
+#include <common_type/assoc/string_form.hpp>
+#include <iterator>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      template<typename It, class Cntnr, bool LOR>
+      class find_find_functor
+      {
+      public:
+        find_find_functor(Cntnr& contnr,  It fnd_it_b,  It fnd_it_e) 
+	: m_contnr(contnr), m_fnd_it_b(fnd_it_b), m_fnd_it_e(fnd_it_e)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  for (std::size_t i = 0; i < resolution; ++i)
+	    {
+	      It fnd_it = m_fnd_it_b;
+	      while (fnd_it != m_fnd_it_e)
+                ++m_contnr.find((fnd_it++)->first)->second;
+	    }
+	}
+
+      private:
+	Cntnr& m_contnr;
+	const It m_fnd_it_b;
+	const It m_fnd_it_e;
+      };
+
+      template<typename It, class Cntnr>
+      class find_find_functor<It, Cntnr, true>
+      {
+      public:
+        find_find_functor(Cntnr& contnr,  It fnd_it_b,  It fnd_it_e) 
+	: m_contnr(contnr), m_fnd_it_b(fnd_it_b), m_fnd_it_e(fnd_it_e)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  It fnd_it = m_fnd_it_b;
+	  while (fnd_it != m_fnd_it_e)
+	    {
+	      for (std::size_t i = 0; i < resolution; ++i)
+                ++m_contnr.find(fnd_it->first)->second;
+	      ++fnd_it;
+	    }
+	}
+
+      private:
+	Cntnr& m_contnr;
+	const It m_fnd_it_b;
+	const It m_fnd_it_e;
+      };
+    } // namespace detail
+
+    template<typename It, bool LOR = false>
+    class find_test : private __gnu_pbds::test::detail::timing_test_base
+    {
+    public:
+      find_test(It ins_b, It fnd_it_b, size_t ins_vn, size_t ins_vs, 
+		size_t ins_vm, size_t fnd_vn, size_t fnd_vs, size_t fnd_vm):
+      m_ins_b(ins_b), m_fnd_it_b(fnd_it_b), m_ins_vn(ins_vn), m_ins_vs(ins_vs),
+      m_ins_vm(ins_vm), m_fnd_vn(fnd_vn), m_fnd_vs(fnd_vs), m_fnd_vm(fnd_vm)
+      { }
+
+      template<typename Cntnr>
+      void
+      operator()(Cntnr);
+
+    private:
+      find_test(const find_test& );
+
+    private:
+      const It 		m_ins_b;
+      const It 		m_fnd_it_b;
+      const size_t 	m_ins_vn;
+      const size_t 	m_ins_vs;
+      const size_t 	m_ins_vm;
+      const size_t 	m_fnd_vn;
+      const size_t 	m_fnd_vs;
+      const size_t 	m_fnd_vm;
+    };
+
+    template<typename It, bool LOR>
+    template<typename Cntnr>
+    void
+    find_test<It, LOR>::
+    operator()(Cntnr)
+    {
+      typedef string_form<Cntnr> sform_type;
+      typedef xml_result_set_performance_formatter formatter_type;
+      formatter_type res_set_fmt(sform_type::name(), sform_type::desc());
+
+      for (size_t i = 0; m_ins_vn + i * m_ins_vs < m_ins_vm; ++i)
+	{
+	  const size_t v = m_ins_vn + i * m_ins_vs;
+	  const size_t fnd_size = m_fnd_vn + i * m_fnd_vs;
+	  It ins_it_b = m_ins_b;
+	  It ins_it_e = m_ins_b;
+	  std::advance(ins_it_e, v);
+
+	  Cntnr test_container(ins_it_b, ins_it_e);
+	  It fnd_it_b = m_fnd_it_b;
+	  It fnd_it_e = m_fnd_it_b;
+	  std::advance(fnd_it_e, fnd_size);
+
+	  __gnu_pbds::test::detail::find_find_functor<It, Cntnr, LOR>
+            fn(test_container, fnd_it_b, fnd_it_e);
+
+	  const double res =
+            __gnu_pbds::test::detail::timing_test_base::operator()(fn);
+	  res_set_fmt.add_res(v, res / fnd_size);
+	}
+    }
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
+
diff --git a/libstdc++-v3/testsuite/util/performance/assoc/timing/insert_test.hpp b/libstdc++-v3/testsuite/util/performance/assoc/timing/insert_test.hpp
new file mode 100644
index 000000000..e71d755ba
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/assoc/timing/insert_test.hpp
@@ -0,0 +1,143 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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_test.hpp
+ * Contains an insert performance test.
+ */
+
+#ifndef PB_DS_INSERT_TEST_HPP
+#define PB_DS_INSERT_TEST_HPP
+
+#include <performance/time/timing_test_base.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <performance/io/xml_formatter.hpp>
+#include <common_type/assoc/string_form.hpp>
+#include <iterator>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      template<typename It, class Cntnr>
+      class insert_insert_functor
+      {
+      public:
+        insert_insert_functor(It ins_it_b,  It ins_it_e) 
+	: m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  for (std::size_t i = 0; i < resolution; ++i)
+	    {
+	      Cntnr cntnr;
+	      for (It ins_it = m_ins_it_b; ins_it != m_ins_it_e; ++ins_it)
+                cntnr.insert((typename Cntnr::const_reference)(*ins_it));
+	    }
+	}
+
+      private:
+	const It m_ins_it_b;
+	const It m_ins_it_e;
+      };
+    } // namespace detail
+
+    template<typename It>
+    class insert_test : private __gnu_pbds::test::detail::timing_test_base
+    {
+    public:
+      insert_test(It ins_b, size_t ins_vn, size_t ins_vs, size_t ins_vm)
+      :  m_ins_b(ins_b), m_ins_vn(ins_vn), m_ins_vs(ins_vs), m_ins_vm(ins_vm)
+      { }
+
+      template<typename Cntnr>
+      void
+      operator()(Cntnr);
+
+    private:
+      insert_test(const insert_test& );
+
+      template<typename Cntnr>
+      void
+      insert(Cntnr, It ins_it_b, It ins_it_e);
+
+      const It m_ins_b;
+      const size_t m_ins_vn;
+      const size_t m_ins_vs;
+      const size_t m_ins_vm;
+    };
+
+    template<typename It>
+    template<typename Cntnr>
+    void
+    insert_test<It>::
+    operator()(Cntnr)
+    {
+      typedef xml_result_set_performance_formatter formatter_type;
+      formatter_type res_set_fmt(string_form<Cntnr>::name(),
+				 string_form<Cntnr>::desc());
+
+      for (size_t i = 0; m_ins_vn + i*  m_ins_vs < m_ins_vm; ++i)
+	{
+	  const size_t v = m_ins_vn + i*  m_ins_vs;
+	  It ins_it_b = m_ins_b;
+	  It ins_it_e = m_ins_b;
+	  std::advance(ins_it_e, v);
+
+	  __gnu_pbds::test::detail::insert_insert_functor<It, Cntnr>
+            fn(ins_it_b, ins_it_e);
+
+	  const double res =
+            __gnu_pbds::test::detail::timing_test_base::operator()(fn);
+
+	  res_set_fmt.add_res(v, res / v);
+	}
+    }
+
+    template<typename It>
+    template<typename Cntnr>
+    void
+    insert_test<It>::
+    insert(Cntnr, It ins_it_b, It ins_it_e)
+    {
+      Cntnr cntnr;
+      for (It ins_it = ins_it_b; ins_it != ins_it_e; ++ins_it)
+        cntnr.insert((typename Cntnr::const_reference)(*ins_it));
+    }
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif
+
diff --git a/libstdc++-v3/testsuite/util/performance/assoc/timing/multimap_find_test.hpp b/libstdc++-v3/testsuite/util/performance/assoc/timing/multimap_find_test.hpp
new file mode 100644
index 000000000..7e3f95bfc
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/assoc/timing/multimap_find_test.hpp
@@ -0,0 +1,191 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2007, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 multimap_find_test.hpp
+ * Contains a generic multimap_find_test test.
+ */
+
+#ifndef PB_DS_MULTIMAP_INSERT_TEST_HPP
+#define PB_DS_MULTIMAP_INSERT_TEST_HPP
+
+#include <performance/time/timing_test_base.hpp>
+#include <performance/io/xml_formatter.hpp>
+#include <common_type/assoc/string_form.hpp>
+#include <iterator>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      template<typename It, class Cntnr, bool Native>
+      class multimap_find_functor
+      {
+      public:
+        multimap_find_functor(const Cntnr& container, It fnd_it_b, It fnd_it_e)
+	: m_r_container(container), m_fnd_it_b(fnd_it_b), m_fnd_it_e(fnd_it_e)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  size_t not_found_count = 0;
+	  typedef typename Cntnr::const_point_iterator iterator_type;
+	  for (std::size_t i = 0; i < resolution; ++i)
+	    {
+	      iterator_type end = m_r_container.end();
+	      for (It fnd_it = m_fnd_it_b; fnd_it != m_fnd_it_e; ++fnd_it)
+		{
+		  iterator_type it = m_r_container.find(fnd_it->first);
+		  if (it == end ||
+		      it->second.find(fnd_it->second) == it->second.end())
+                    ++not_found_count;
+		}
+	    }
+
+	  if (not_found_count != 0)
+            std::abort();
+	}
+
+      private:
+	const Cntnr& m_r_container;
+	const It m_fnd_it_b;
+	const It m_fnd_it_e;
+      };
+
+      template<typename It, class Cntnr>
+      class multimap_find_functor<It, Cntnr, true>
+      {
+      public:
+        multimap_find_functor(const Cntnr& container, It fnd_it_b, It fnd_it_e)
+	: m_r_container(container), m_fnd_it_b(fnd_it_b), m_fnd_it_e(fnd_it_e)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  typedef typename Cntnr::const_reference const_reference;
+	  size_t not_found_count = 0;
+	  for (std::size_t i = 0; i < resolution; ++i)
+	    {
+	      Cntnr cntnr;
+	      for (It fnd_it = m_fnd_it_b; fnd_it != m_fnd_it_e; ++fnd_it)
+                if (m_r_container.find(const_reference(*fnd_it)) 
+		    == m_r_container.end())
+		  ++not_found_count;
+	    }
+
+	  if (not_found_count != 0)
+            std::abort();
+	}
+
+      private:
+	const Cntnr& m_r_container;
+	const It m_fnd_it_b;
+	const It m_fnd_it_e;
+      };
+    } // namespace detail
+
+
+    template<typename It, bool Native>
+    class multimap_find_test 
+    : private __gnu_pbds::test::detail::timing_test_base
+    {
+    public:
+      multimap_find_test(It ins_b, size_t ins_vn, size_t vs, size_t ins_vm)
+      : m_ins_b(ins_b), m_ins_vn(ins_vn), m_ins_vs(vs), m_ins_vm(ins_vm)
+      { }
+
+      template<typename Cntnr>
+      void
+      operator()(Cntnr);
+
+    private:
+      multimap_find_test(const multimap_find_test&);
+
+      template<typename Cntnr>
+      Cntnr
+      init(It ins_b, It ins_e, Cntnr, __gnu_pbds::detail::true_type)
+      { return Cntnr(ins_b, ins_e); }
+
+      template<typename Cntnr>
+      Cntnr
+      init(It ins_b, It ins_e, Cntnr, __gnu_pbds::detail::false_type)
+      {
+	Cntnr ret;
+	for (It it = ins_b; it != ins_e; ++it)
+	  ret[it->first].insert(it->second);
+	return ret;
+      }
+
+      const It m_ins_b;
+      const size_t m_ins_vn;
+      const size_t m_ins_vs;
+      const size_t m_ins_vm;
+    };
+
+
+    template<typename It, bool Native>
+    template<typename Cntnr>
+    void
+    multimap_find_test<It, Native>::
+    operator()(Cntnr)
+    {
+      typedef xml_result_set_performance_formatter formatter_type;
+      formatter_type res_set_fmt(string_form<Cntnr>::name(),
+				 string_form<Cntnr>::desc());
+
+      for (size_t i = 0; m_ins_vn + i * m_ins_vs < m_ins_vm; ++i)
+	{
+	  const size_t v = m_ins_vn + i * m_ins_vs;
+	  It ins_it_b = m_ins_b;
+	  It ins_it_e = m_ins_b;
+	  std::advance(ins_it_e, v);
+
+	  Cntnr c = init(ins_it_b, ins_it_e, Cntnr(),
+			 __gnu_pbds::detail::integral_constant<int,Native>());
+
+	  __gnu_pbds::test::detail::multimap_find_functor<It, Cntnr, Native>
+            fn(c, ins_it_b, ins_it_e);
+
+	  const double res =
+            __gnu_pbds::test::detail::timing_test_base::operator()(fn);
+
+	  res_set_fmt.add_res(v, res / v);
+	}
+    }
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
+
diff --git a/libstdc++-v3/testsuite/util/performance/assoc/timing/multimap_insert_test.hpp b/libstdc++-v3/testsuite/util/performance/assoc/timing/multimap_insert_test.hpp
new file mode 100644
index 000000000..2e8539857
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/assoc/timing/multimap_insert_test.hpp
@@ -0,0 +1,151 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 multimap_insert_test.hpp
+ * Contains a generic multimap_insert_test test.
+ */
+
+#ifndef PB_DS_MULTIMAP_INSERT_TEST_HPP
+#define PB_DS_MULTIMAP_INSERT_TEST_HPP
+
+#include <performance/time/timing_test_base.hpp>
+#include <performance/io/xml_formatter.hpp>
+#include <common_type/assoc/string_form.hpp>
+#include <iterator>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      template<typename It, class Cntnr, bool Native>
+      class multimap_insert_functor
+      {
+      public:
+        multimap_insert_functor(It ins_it_b, It ins_it_e) 
+	: m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  for (std::size_t i = 0; i < resolution; ++i)
+	    {
+	      Cntnr cntnr;
+	      for (It ins_it = m_ins_it_b; ins_it != m_ins_it_e; ++ins_it)
+                cntnr[ins_it->first].insert(ins_it->second);
+	    }
+	}
+
+      private:
+	const It m_ins_it_b;
+	const It m_ins_it_e;
+      };
+
+      template<typename It, class Cntnr>
+      class multimap_insert_functor<It, Cntnr, true>
+      {
+      public:
+        multimap_insert_functor(It ins_it_b,  It ins_it_e) 
+	: m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  for (std::size_t i = 0; i < resolution; ++i)
+	    {
+	      Cntnr cntnr;
+	      for (It ins_it = m_ins_it_b; ins_it != m_ins_it_e; ++ins_it)
+		cntnr.insert((typename Cntnr::const_reference)(*ins_it));
+	    }
+	}
+
+      private:
+	const It m_ins_it_b;
+	const It m_ins_it_e;
+      };
+    } // namespace detail
+
+    template<typename It, bool Native>
+    class multimap_insert_test 
+    : private __gnu_pbds::test::detail::timing_test_base
+    {
+    public:
+      multimap_insert_test(It b, size_t ins_vn, size_t ins_vs, size_t ins_vm) 
+      : m_ins_b(b), m_ins_vn(ins_vn), m_ins_vs(ins_vs), m_ins_vm(ins_vm)
+      { }
+
+      template<typename Cntnr>
+      void
+      operator()(Cntnr);
+
+    private:
+      multimap_insert_test(const multimap_insert_test&);
+
+      const It m_ins_b;
+      const size_t m_ins_vn;
+      const size_t m_ins_vs;
+      const size_t m_ins_vm;
+    };
+
+    template<typename It, bool Native>
+    template<typename Cntnr>
+    void
+    multimap_insert_test<It, Native>::
+    operator()(Cntnr)
+    {
+      typedef xml_result_set_performance_formatter formatter_type;
+      formatter_type res_set_fmt(string_form<Cntnr>::name(),
+				 string_form<Cntnr>::desc());
+
+      for (size_t i = 0; m_ins_vn + i * m_ins_vs < m_ins_vm; ++i)
+	{
+	  const size_t v = m_ins_vn + i * m_ins_vs;
+	  It ins_it_b = m_ins_b;
+	  It ins_it_e = m_ins_b;
+	  std::advance(ins_it_e, v);
+
+	  __gnu_pbds::test::detail::multimap_insert_functor<It, Cntnr, Native>
+            fn(ins_it_b, ins_it_e);
+
+	  const double res =
+            __gnu_pbds::test::detail::timing_test_base::operator()(fn);
+	  res_set_fmt.add_res(v, res / v);
+	}
+    }
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif
+
diff --git a/libstdc++-v3/testsuite/util/performance/assoc/timing/subscript_find_test.hpp b/libstdc++-v3/testsuite/util/performance/assoc/timing/subscript_find_test.hpp
new file mode 100644
index 000000000..d37121b8c
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/assoc/timing/subscript_find_test.hpp
@@ -0,0 +1,144 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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_find_test.hpp
+ * Contains a generic subscript_find_test test.
+ */
+
+#ifndef PB_DS_SUBSCRIPT_TEST_HPP
+#define PB_DS_SUBSCRIPT_TEST_HPP
+
+#include <performance/time/timing_test_base.hpp>
+#include <common_type/assoc/string_form.hpp>
+#include <iterator>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      template<typename It, class Cntnr>
+      class subscript_find_functor
+      {
+      public:
+        subscript_find_functor(Cntnr& container,  It fnd_it_b,  It fnd_it_e) 
+	: m_r_container(container), m_fnd_it_b(fnd_it_b), m_fnd_it_e(fnd_it_e)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  for (std::size_t i = 0; i < resolution; ++i)
+	    {
+	      It fnd_it = m_fnd_it_b;
+	      while (fnd_it != m_fnd_it_e)
+                ++m_r_container[(fnd_it++)->first];
+	      ++fnd_it;
+	    }
+	}
+
+      private:
+	Cntnr& m_r_container;
+	const It m_fnd_it_b;
+	const It m_fnd_it_e;
+      };
+
+    } // namespace detail
+
+    template<typename It>
+    class subscript_find_test : private __gnu_pbds::test::detail::timing_test_base
+    {
+    public:
+      subscript_find_test(It ins_b, It b, size_t ins_vn, size_t ins_vs, 
+			  size_t ins_vm, size_t vn, size_t vs, size_t vm)
+      : m_ins_b(ins_b), m_fnd_b(b), m_ins_vn(ins_vn), m_ins_vs(ins_vs),
+	m_ins_vm(ins_vm), m_fnd_vn(vn), m_fnd_vs(vs), m_fnd_vm(vm)
+      { }
+
+      template<typename Cntnr>
+      void
+      operator()(Cntnr);
+
+    private:
+      subscript_find_test(const subscript_find_test&);
+
+    private:
+      const It m_ins_b;
+      const It m_fnd_b;
+      const size_t m_ins_vn;
+      const size_t m_ins_vs;
+      const size_t m_ins_vm;
+      const size_t m_fnd_vn;
+      const size_t m_fnd_vs;
+      const size_t m_fnd_vm;
+    };
+
+   template<typename It>
+   template<typename Cntnr>
+    void
+    subscript_find_test<It>::
+    operator()(Cntnr)
+    {
+      typedef xml_result_set_performance_formatter formatter_type;
+      formatter_type res_set_fmt(string_form<Cntnr>::name(),
+				 string_form<Cntnr>::desc());
+
+      for (size_t i = 0; m_ins_vn + i*  m_ins_vs < m_ins_vm; ++i)
+	{
+	  const size_t v = m_ins_vn + i*  m_ins_vs;
+	  const size_t fnd_size = m_fnd_vn + i*  m_fnd_vs;
+
+	  It ins_it_b = m_ins_b;
+	  It ins_it_e = m_ins_b;
+	  std::advance(ins_it_e, v);
+
+	  Cntnr test_container(ins_it_b, ins_it_e);
+
+	  It fnd_it_b = m_fnd_b;
+	  It fnd_it_e = m_fnd_b;
+	  std::advance(fnd_it_e, fnd_size);
+
+	  __gnu_pbds::test::detail::subscript_find_functor<It, Cntnr>
+            fn(test_container, fnd_it_b, fnd_it_e);
+
+	  const double res =
+            __gnu_pbds::test::detail::timing_test_base::operator()(fn);
+
+	  res_set_fmt.add_res(v, res / fnd_size);
+	}
+    }
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
+
diff --git a/libstdc++-v3/testsuite/util/performance/assoc/timing/subscript_insert_test.hpp b/libstdc++-v3/testsuite/util/performance/assoc/timing/subscript_insert_test.hpp
new file mode 100644
index 000000000..10925fd60
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/assoc/timing/subscript_insert_test.hpp
@@ -0,0 +1,134 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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_insert_test.hpp
+ * Contains a generic subscript_insert_test test.
+ */
+
+#ifndef PB_DS_SUBSCRIPT_TEST_HPP
+#define PB_DS_SUBSCRIPT_TEST_HPP
+
+#include <performance/time/timing_test_base.hpp>
+#include <performance/io/xml_formatter.hpp>
+#include <common_type/assoc/string_form.hpp>
+#include <iterator>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      template<typename It, class Cntnr>
+      class subscript_insert_functor
+      {
+      public:
+        subscript_insert_functor(It ins_it_b,  It ins_it_e) 
+	: m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  for (std::size_t i = 0; i < resolution; ++i)
+	    {
+	      Cntnr cntnr;
+	      for (It ins_it = m_ins_it_b; ins_it != m_ins_it_e; ++ins_it)
+                ++cntnr[ins_it->first];
+	    }
+	}
+
+      private:
+	const It m_ins_it_b;
+	const It m_ins_it_e;
+      };
+
+    } // namespace detail
+
+    template<typename It>
+    class subscript_insert_test : private __gnu_pbds::test::detail::timing_test_base
+    {
+    public:
+      subscript_insert_test(It ins_b, It b, size_t ins_vn, size_t ins_vs, 
+			    size_t ins_vm, size_t vn, size_t vs, size_t vm)
+      : m_ins_b(ins_b), m_fnd_b(b), m_ins_vn(ins_vn), m_ins_vs(ins_vs), 
+	m_ins_vm(ins_vm), m_fnd_vn(vn), m_fnd_vs(vs), m_fnd_vm(vm)
+      { }
+
+      template<typename Cntnr>
+      void
+      operator()(Cntnr);
+
+    private:
+      subscript_insert_test(const subscript_insert_test& );
+
+    private:
+      const It m_ins_b;
+      const It m_fnd_b;
+      const size_t m_ins_vn;
+      const size_t m_ins_vs;
+      const size_t m_ins_vm;
+      const size_t m_fnd_vn;
+      const size_t m_fnd_vs;
+      const size_t m_fnd_vm;
+    };
+
+    template<typename It>
+    template<typename Cntnr>
+    void
+    subscript_insert_test<It>::
+    operator()(Cntnr)
+    {
+      typedef xml_result_set_performance_formatter formatter_type;
+      formatter_type res_set_fmt(string_form<Cntnr>::name(),
+				 string_form<Cntnr>::desc());
+
+      for (size_t i = 0; m_ins_vn + i * m_ins_vs < m_ins_vm; ++i)
+	{
+	  const size_t v = m_ins_vn + i * m_ins_vs;
+	  It ins_it_b = m_ins_b;
+	  It ins_it_e = m_ins_b;
+	  std::advance(ins_it_e, v);
+	  __gnu_pbds::test::detail::subscript_insert_functor<It, Cntnr>
+            fn(ins_it_b, ins_it_e);
+
+	  const double res =
+            __gnu_pbds::test::detail::timing_test_base::operator()(fn);
+
+	  res_set_fmt.add_res(v, res / v);
+	}
+    }
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
+
diff --git a/libstdc++-v3/testsuite/util/performance/assoc/timing/tree_order_statistics_test.hpp b/libstdc++-v3/testsuite/util/performance/assoc/timing/tree_order_statistics_test.hpp
new file mode 100644
index 000000000..0fb028687
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/assoc/timing/tree_order_statistics_test.hpp
@@ -0,0 +1,176 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2007, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 tree_order_statistics_test.hpp
+ * Contains a test for order_statisticsing trees
+ */
+
+#ifndef PB_DS_TREE_ORDER_STATISTICS_TEST_HPP
+#define PB_DS_TREE_ORDER_STATISTICS_TEST_HPP
+
+#include <performance/time/timing_test_base.hpp>
+#include <performance/io/xml_formatter.hpp>
+#include <common_type/assoc/string_form.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <iterator>
+#include <cstdlib>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      template<typename Cntnr, bool Native>
+      class order_statistics_functor
+      {
+      public:
+        order_statistics_functor(Cntnr& container) : m_r_container(container)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  enum
+	    {
+	      support_detected =
+	      __gnu_pbds::test::detail::tree_supports_order_statistics<Cntnr>::value
+	    };
+
+	  PB_DS_STATIC_ASSERT(correct_type, support_detected);
+
+	  for (std::size_t i = 0; i < resolution; ++i)
+	    {
+	      typename Cntnr::const_iterator it = m_r_container.begin();
+	      typename Cntnr::const_iterator e = m_r_container.end();
+	      const size_t max_size = m_r_container.size();
+	      while (it != e)
+		if (m_r_container.order_of_key(*(it++)) > max_size)
+		  std::abort();
+	    }
+	}
+
+      private:
+	Cntnr& m_r_container;
+      };
+
+      template<typename Cntnr>
+      class order_statistics_functor<Cntnr, false>
+      {
+      public:
+        order_statistics_functor(Cntnr& container) : m_r_container(container)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  for (std::size_t i = 0; i < resolution; ++i)
+	    {
+	      typedef typename Cntnr::const_iterator const_iterator;
+	      const_iterator b = m_r_container.begin();
+	      const_iterator e = m_r_container.end();
+	      const_iterator it = b;
+	      const size_t max_size = m_r_container.size();
+	      while (it != e)
+		{
+		  const_iterator f_it = m_r_container.find(*(it++));
+		  if (static_cast<size_t>(std::distance(b, f_it)) > max_size)
+		    std::abort();
+		}
+	    }
+	}
+
+      private:
+	Cntnr& m_r_container;
+      };
+    } // namespace detail
+
+    template<bool Support_Order_Statistics>
+    class tree_order_statistics_test 
+    : private __gnu_pbds::test::detail::timing_test_base
+    {
+    public:
+      tree_order_statistics_test(size_t vn, size_t vs, size_t vm)
+      : m_vn(vn), m_vs(vs), m_vm(vm)
+      { }
+
+      template<typename Cntnr>
+      void
+      operator()(Cntnr);
+
+    private:
+      tree_order_statistics_test(const tree_order_statistics_test& );
+
+      template<typename Cntnr>
+      void
+      order_statistics(Cntnr& r_container, __gnu_pbds::detail::true_type);
+
+      template<typename Cntnr>
+      void
+      order_statistics(Cntnr& r_container, __gnu_pbds::detail::false_type);
+
+    private:
+      const size_t m_vn;
+      const size_t m_vs;
+      const size_t m_vm;
+    };
+
+    template<bool Support_Order_Statistics>
+    template<typename Cntnr>
+    void
+    tree_order_statistics_test<Support_Order_Statistics>::
+    operator()(Cntnr)
+    {
+      typedef xml_result_set_performance_formatter formatter_type;
+      formatter_type res_set_fmt(string_form<Cntnr>::name(), 
+				 string_form<Cntnr>::desc());
+
+      for (size_t v = m_vn; v < m_vm; v += m_vs)
+	{
+	  Cntnr cntnr;
+	  for (size_t ins = 0; ins < v; ++ ins)
+            cntnr.insert((typename Cntnr::value_type)ins);
+
+	  __gnu_pbds::test::detail::order_statistics_functor<Cntnr, Support_Order_Statistics>
+            fn(cntnr);
+
+	  const double res =
+            __gnu_pbds::test::detail::timing_test_base::operator()(fn);
+
+	  res_set_fmt.add_res(v, res / v);
+	}
+    }
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
+
diff --git a/libstdc++-v3/testsuite/util/performance/assoc/timing/tree_split_join_test.hpp b/libstdc++-v3/testsuite/util/performance/assoc/timing/tree_split_join_test.hpp
new file mode 100644
index 000000000..6872291df
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/assoc/timing/tree_split_join_test.hpp
@@ -0,0 +1,158 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 tree_split_join_test.hpp
+ * Contains a test for splitting and joining trees
+ */
+
+#ifndef PB_DS_TREE_SPLIT_JOIN_TEST_HPP
+#define PB_DS_TREE_SPLIT_JOIN_TEST_HPP
+
+#include <performance/time/timing_test_base.hpp>
+#include <performance/io/xml_formatter.hpp>
+#include <common_type/assoc/string_form.hpp>
+#include <iterator>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      template<typename Cntnr, bool Support_Split_Join>
+      class split_join_functor
+      {
+      public:
+        split_join_functor(Cntnr& r_container) : m_r_container(r_container)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  for (std::size_t i = 0; i < resolution; ++i)
+	    {
+	      typename Cntnr::const_iterator mid_it = m_r_container.begin();
+	      std::advance(mid_it, m_r_container.size() / 2);
+	      Cntnr other;
+	      m_r_container.split(*mid_it, other);
+	      m_r_container.join(other);
+	    }
+	}
+
+      private:
+	Cntnr& m_r_container;
+      };
+
+      template<typename Cntnr>
+      class split_join_functor<Cntnr, false>
+      {
+      public:
+        split_join_functor(Cntnr& r_container) : m_r_container(r_container)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  for (std::size_t i = 0; i < resolution; ++i)
+	    {
+	      typename Cntnr::iterator mid_it = m_r_container.begin();
+	      std::advance(mid_it, m_r_container.size() / 2);
+
+	      Cntnr other(mid_it, m_r_container.end());
+	      m_r_container.erase(mid_it, m_r_container.end());
+
+	      m_r_container.insert(other.begin(), other.end());
+	      other.clear();
+	    }
+	}
+
+      private:
+	Cntnr& m_r_container;
+      };
+    } // namespace detail
+
+    template<bool Support_Split_Join>
+    class tree_split_join_test : private __gnu_pbds::test::detail::timing_test_base
+    {
+    public:
+      tree_split_join_test(size_t vn, size_t vs, size_t vm);
+
+      template<typename Cntnr>
+      void
+      operator()(Cntnr);
+
+    private:
+      tree_split_join_test(const tree_split_join_test& );
+
+    private:
+      const size_t m_vn;
+      const size_t m_vs;
+      const size_t m_vm;
+    };
+
+    template<bool Support_Split_Join>
+    tree_split_join_test<Support_Split_Join>::
+    tree_split_join_test(size_t vn, size_t vs, size_t vm) :
+      m_vn(vn),
+      m_vs(vs),
+      m_vm(vm)
+    { }
+
+    template<bool Support_Split_Join>
+    template<typename Cntnr>
+    void
+    tree_split_join_test<Support_Split_Join>::
+    operator()(Cntnr)
+    {
+      typedef xml_result_set_performance_formatter formatter_type;
+      formatter_type res_set_fmt(string_form<Cntnr>::name(),
+				 string_form<Cntnr>::desc());
+
+      for (size_t v = m_vn; v < m_vm; v += m_vs)
+	{
+	  Cntnr cntnr;
+	  for (size_t ins = 0; ins < v; ++ ins)
+            cntnr.insert((typename Cntnr::value_type)ins);
+
+	  __gnu_pbds::test::detail::split_join_functor<Cntnr, Support_Split_Join>
+            fn(cntnr);
+
+	  const double res =
+            __gnu_pbds::test::detail::timing_test_base::operator()(fn);
+	  res_set_fmt.add_res(v, res);
+	}
+    }
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
+
diff --git a/libstdc++-v3/testsuite/util/performance/io/xml_formatter.hpp b/libstdc++-v3/testsuite/util/performance/io/xml_formatter.hpp
new file mode 100644
index 000000000..535964bdd
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/io/xml_formatter.hpp
@@ -0,0 +1,78 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 performance tests.
+ */
+
+#ifndef PB_DS_XML_TEST_PERFORMANCE_FORMATTER_HPP
+#define PB_DS_XML_TEST_PERFORMANCE_FORMATTER_HPP
+
+#include <string>
+#include <iostream>
+#include <io/xml_test_formatter.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    class xml_test_performance_formatter : public xml_test_formatter
+    {
+    public:
+      xml_test_performance_formatter(const std::string& r_x_name, const std::string& r_y_name)
+      {
+	std::cout << make_xml_tag("x_name", r_x_name);
+	std::cout << make_xml_tag("y_name", r_y_name);
+      }
+    };
+
+    class xml_result_set_performance_formatter : public xml_result_set_formatter
+    {
+    public:
+      xml_result_set_performance_formatter(const std::string& r_container_name, const std::string& r_container_desc)
+	:  xml_result_set_formatter(r_container_name, r_container_desc)
+      {
+	{ }
+      }
+
+      void
+      add_res(size_t x, double y)
+      {
+	const unsigned long ul = static_cast<unsigned long>(x);
+	const std::string res = make_xml_tag("result", "x", ul, "y", y);
+	std::cout << res;
+      }
+    };
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_XML_TEST_PERFORMANCE_FORMATTER_HPP
diff --git a/libstdc++-v3/testsuite/util/performance/priority_queue/mem_usage/pop_test.hpp b/libstdc++-v3/testsuite/util/performance/priority_queue/mem_usage/pop_test.hpp
new file mode 100644
index 000000000..3a98813df
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/priority_queue/mem_usage/pop_test.hpp
@@ -0,0 +1,111 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 pop_test.hpp
+ * Contains a generic pop test.
+ */
+
+#ifndef PB_DS_POP_TEST_HPP
+#define PB_DS_POP_TEST_HPP
+
+#include <iterator>
+#include <testsuite_allocator.h>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <performance/io/xml_formatter.hpp>
+#include <common_type/priority_queue/string_form.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    template<typename It>
+    class pop_test
+    {
+    public:
+      pop_test(It ins_b, size_t ins_vn, size_t ins_vs, size_t ins_vm)
+      : m_ins_b(ins_b), m_ins_vn(ins_vn), m_ins_vs(ins_vs), m_ins_vm(ins_vm)
+      { }
+
+      template<typename Cntnr>
+      void
+      operator()(Cntnr);
+
+    private:
+      pop_test(const pop_test&);
+
+      const It m_ins_b;
+      const size_t m_ins_vn;
+      const size_t m_ins_vs;
+      const size_t m_ins_vm;
+    };
+
+    template<typename It>
+    template<typename Cntnr>
+    void
+    pop_test<It>::
+    operator()(Cntnr)
+    {
+      typedef xml_result_set_performance_formatter formatter_type;
+     formatter_type res_set_fmt(string_form<Cntnr>::name(),
+				string_form<Cntnr>::desc());
+
+      for (size_t i = 0; m_ins_vn + i * m_ins_vs < m_ins_vm; ++i)
+	{
+	  const size_t ins_size = m_ins_vn + i * m_ins_vs;
+	  It ins_it_b = m_ins_b;
+	  It ins_it_e = m_ins_b;
+	  std::advance(ins_it_e, ins_size);
+
+	  typedef __gnu_test::tracker_allocator_counter counter_type;
+	  __gnu_test::tracker_allocator<char> alloc;
+
+	  const size_t init_mem = counter_type::get_allocation_count() 
+	                          - counter_type::get_deallocation_count();
+	  Cntnr cntnr;
+	  for (It ins_it =    ins_it_b; ins_it != ins_it_e; ++ins_it)
+            cntnr.push(ins_it->first);
+
+	  while (cntnr.size() > 1)
+            cntnr.pop();
+
+	  const size_t final_mem = counter_type::get_allocation_count() 
+	                           - counter_type::get_deallocation_count();
+	  assert(final_mem > init_mem);
+	  const size_t delta_mem = final_mem - init_mem;
+	  res_set_fmt.add_res(ins_size, static_cast<double>(delta_mem));
+	}
+    }
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
+
diff --git a/libstdc++-v3/testsuite/util/performance/priority_queue/timing/join_test.hpp b/libstdc++-v3/testsuite/util/performance/priority_queue/timing/join_test.hpp
new file mode 100644
index 000000000..1281f40c3
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/priority_queue/timing/join_test.hpp
@@ -0,0 +1,167 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 join_test.hpp
+ * Contains a join performance test.
+ */
+
+#ifndef PB_DS_JOIN_TEST_HPP
+#define PB_DS_JOIN_TEST_HPP
+
+#include <performance/time/timing_test_base.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <performance/io/xml_formatter.hpp>
+#include <common_type/priority_queue/string_form.hpp>
+#include <iterator>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      template<typename It, typename Cntnr>
+      class double_push_functor
+      {
+	const It _M_begin;
+	const It _M_end;
+
+      public:
+        double_push_functor(It b,  It e) : _M_begin(b), _M_end(e) { }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  typedef typename Cntnr::const_reference const_reference;
+	  for (std::size_t n = 0; n < resolution; ++n)
+	    {
+	      Cntnr c0;
+	      Cntnr c1;
+	      for (It it = _M_begin; it != _M_end; ++it)
+		{
+		  c0.push(const_reference(it->first));
+		  c1.push(const_reference(it->first));
+		}
+	    }
+	}
+      };
+
+      template<typename It, typename Cntnr>
+      class double_push_join_functor
+      {
+	const It _M_begin;
+	const It _M_end;
+
+      public:
+        double_push_join_functor(It b,  It e) : _M_begin(b), _M_end(e) { }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  typedef typename Cntnr::const_reference const_reference;
+	  for (std::size_t n = 0; n < resolution; ++n)
+	    {
+	      Cntnr c0;
+	      Cntnr c1;
+	      for (It it = _M_begin; it != _M_end; ++it)
+		{
+		  c0.push(const_reference(it->first));
+		  c1.push(const_reference(it->first));
+		}
+	      c0.join(c1);
+	    }
+	}
+      };
+    } // namespace detail
+
+    template<typename It>
+    class join_test : private __gnu_pbds::test::detail::timing_test_base
+    {
+    public:
+      join_test(It ins_b, size_t ins_vn, size_t ins_vs, size_t ins_vm)
+      : m_ins_b(ins_b), m_ins_vn(ins_vn), m_ins_vs(ins_vs), m_ins_vm(ins_vm)
+      { }
+
+      template<typename Cntnr>
+      void
+      operator()(Cntnr)
+      {
+	using __gnu_pbds::test::detail::double_push_functor;
+	using __gnu_pbds::test::detail::double_push_join_functor;
+	typedef __gnu_pbds::test::detail::timing_test_base base_type;
+	typedef double_push_functor<It, Cntnr> psh_fnct;
+	typedef double_push_join_functor<It, Cntnr> psh_jn_fnct;
+
+	typedef xml_result_set_performance_formatter formatter_type;
+	formatter_type res(string_form<Cntnr>::name(), 
+			   string_form<Cntnr>::desc());
+	  
+	for (size_t n = 0; m_ins_vn + n*  m_ins_vs < m_ins_vm; ++n)
+	  {
+	    const size_t v = m_ins_vn + n *  m_ins_vs;
+	    It b = m_ins_b;
+	    It e = m_ins_b;
+	    std::advance(e, v);
+
+	    psh_fnct double_push_fn(b, e);
+	    const double dbl_psh_res = base_type::operator()(double_push_fn);
+	    psh_jn_fnct dbl_psh_jn_fn(b, e);
+	    const double dbl_psh_jn_res = base_type::operator()(dbl_psh_jn_fn);
+	    const double min_res = double(timing_test_base::min_time_res());
+	    const double effective_delta = std::max(dbl_psh_jn_res - dbl_psh_res, min_res);
+	    res.add_res(v, effective_delta / v);
+	  }
+      }
+
+    private:
+      join_test(const join_test&);
+
+      template<typename Cntnr>
+      void
+      join(Cntnr, It b, It e)
+      {
+	Cntnr cntnr;
+	typedef typename Cntnr::const_reference const_reference;
+	for (It it = b; it != e; ++it)
+	  cntnr.join(const_reference(*it));
+      }
+
+      const It 		m_ins_b;
+      const size_t 	m_ins_vn;
+      const size_t 	m_ins_vs;
+      const size_t 	m_ins_vm;
+    };
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
+
diff --git a/libstdc++-v3/testsuite/util/performance/priority_queue/timing/modify_test.hpp b/libstdc++-v3/testsuite/util/performance/priority_queue/timing/modify_test.hpp
new file mode 100644
index 000000000..01e082058
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/priority_queue/timing/modify_test.hpp
@@ -0,0 +1,329 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 modify_test.hpp
+ * Contains a modify performance test.
+ */
+
+#ifndef PB_DS_JOIN_TEST_HPP
+#define PB_DS_JOIN_TEST_HPP
+
+#include <performance/time/timing_test_base.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <performance/io/xml_formatter.hpp>
+#include <common_type/priority_queue/string_form.hpp>
+#include <iterator>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      // Primary templates.
+      template<typename It, class Cntnr, class Tag>
+      class push_functor
+      {
+      public:
+        push_functor(It ins_it_b,  It ins_it_e) 
+	: m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  typedef typename Cntnr::point_iterator point_iterator;
+	  typedef typename Cntnr::const_reference const_reference;
+	  for (std::size_t i = 0; i < resolution; ++i)
+	    {
+	      Cntnr c;
+	      typedef std::vector<point_iterator> it_vec_t;
+	      it_vec_t m_a_its;
+	      for (It ins_it = m_ins_it_b; ins_it != m_ins_it_e; ++ins_it)
+                m_a_its.push_back(c.push(const_reference(ins_it->first)));
+	    }
+	}
+
+      private:
+	const It m_ins_it_b;
+	const It m_ins_it_e;
+      };
+
+      template<typename It, class Cntnr, class Tag>
+      class push_modify_functor
+      {
+      private:
+	typedef typename Cntnr::point_iterator point_iterator;
+	typedef typename Cntnr::const_reference const_reference;
+	typedef typename Cntnr::value_type value_type;
+
+      public:
+        push_modify_functor(It ins_it_b, It ins_it_e, value_type mod_val) 
+	: m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e), m_mod_val(mod_val)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  for (std::size_t i = 0; i < resolution; ++i)
+	    {
+	      Cntnr c;
+	      typedef std::vector<typename Cntnr::point_iterator> it_vec_t;
+	      it_vec_t m_a_its;
+	      for (It ins_it = m_ins_it_b; ins_it != m_ins_it_e; ++ins_it)
+                m_a_its.push_back(c.push(const_reference(ins_it->first)));
+
+	      typename it_vec_t::iterator mod_it = m_a_its.begin();
+	      while (mod_it != m_a_its.end())
+                c.modify(*mod_it++, m_mod_val);
+	    }
+	}
+
+      private:
+	const It m_ins_it_b;
+	const It m_ins_it_e;
+	const value_type m_mod_val;
+      };
+
+      // Specializations.
+      template<typename It, class Cntnr>
+      class push_functor<It, Cntnr, __gnu_pbds::binary_heap_tag>
+      {
+      public:
+        push_functor(It ins_it_b,  It ins_it_e) 
+	: m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  typedef typename Cntnr::const_reference const_reference;
+	  for (std::size_t i = 0; i < resolution; ++i)
+	    {
+	      Cntnr c;
+	      for (It ins_it = m_ins_it_b; ins_it != m_ins_it_e; ++ins_it)
+                c.push(const_reference(ins_it->first));
+	    }
+	}
+
+      private:
+	const It m_ins_it_b;
+	const It m_ins_it_e;
+      };
+
+      template<typename It, class Cntnr>
+      class push_functor<It, Cntnr, __gnu_pbds::test::native_pq_tag>
+      {
+      public:
+        push_functor(It ins_it_b,  It ins_it_e) 
+	: m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  typedef typename Cntnr::const_reference const_reference;
+	  for (std::size_t i = 0; i < resolution; ++i)
+	    {
+	      Cntnr c;
+
+	      for (It ins_it = m_ins_it_b; ins_it != m_ins_it_e; ++ins_it)
+                c.push(const_reference(ins_it->first));
+	    }
+	}
+
+      private:
+	const It m_ins_it_b;
+	const It m_ins_it_e;
+      };
+
+
+      template<typename It, class Cntnr>
+      class push_modify_functor<It, Cntnr, __gnu_pbds::binary_heap_tag>
+      {
+      private:
+	typedef typename Cntnr::iterator iterator;
+	typedef typename Cntnr::const_reference const_reference;
+	typedef typename Cntnr::value_type value_type;
+
+      public:
+        push_modify_functor(It ins_it_b, It ins_it_e, value_type mod_val) 
+	: m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e), m_mod_val(mod_val)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  for (std::size_t i = 0; i < resolution; ++i)
+	    {
+	      Cntnr c;
+	      It ins_it;
+	      for (ins_it = m_ins_it_b; ins_it != m_ins_it_e; ++ins_it)
+                c.push(const_reference(ins_it->first));
+
+	      for (ins_it = m_ins_it_b; ins_it != m_ins_it_e; ++ins_it)
+		{
+		  bool modified = false;
+		  for (iterator it = c.begin(); !modified && it != c.end(); ++it)
+                    if (*it == ins_it->first)
+		      {
+                        c.modify(it, m_mod_val);
+                        modified = true;
+		      }
+		}
+	    }
+	}
+
+      private:
+	const It m_ins_it_b;
+	const It m_ins_it_e;
+	const value_type m_mod_val;
+      };
+
+      template<typename It, class Cntnr>
+      class push_modify_functor<It, Cntnr, __gnu_pbds::test::native_pq_tag>
+      {
+      private:
+	typedef typename Cntnr::value_type value_type;
+	typedef typename Cntnr::const_reference const_reference;
+
+      public:
+        push_modify_functor(It ins_it_b,  It ins_it_e, value_type mod_val) 
+	: m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e), m_mod_val(mod_val)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  for (std::size_t i = 0; i < resolution; ++i)
+	    {
+	      Cntnr c;
+	      It ins_it;
+	      for (ins_it = m_ins_it_b; ins_it != m_ins_it_e; ++ins_it)
+                c.push(const_reference(ins_it->first));
+	      for (ins_it = m_ins_it_b; ins_it != m_ins_it_e; ++ins_it)
+                c.modify(ins_it->first, m_mod_val);
+	    }
+	}
+
+      private:
+	const It m_ins_it_b;
+	const It m_ins_it_e;
+	const value_type m_mod_val;
+      };
+    } // namespace detail
+
+    template<typename It>
+    class modify_test : private __gnu_pbds::test::detail::timing_test_base
+    {
+    public:
+      modify_test(It b, size_t vn, size_t vs, size_t vm, bool modify_up)
+      : m_ins_b(b), m_ins_vn(vn), m_ins_vs(vs), m_ins_vm(vm),
+      m_modify_up(modify_up)
+      { }
+
+      template<typename Cntnr>
+      void
+      operator()(Cntnr);
+
+    private:
+      modify_test(const modify_test&);
+
+      template<typename Cntnr>
+      void
+      modify(Cntnr, It ins_it_b, It ins_it_e)
+      {
+	typedef typename Cntnr::const_reference const_reference;
+	Cntnr cntnr;	
+	for (It ins_it = ins_it_b; ins_it != ins_it_e; ++ins_it)
+	  cntnr.modify(const_reference(*ins_it));
+      }
+
+      const It m_ins_b;
+      const size_t m_ins_vn;
+      const size_t m_ins_vs;
+      const size_t m_ins_vm;
+      const bool m_modify_up;
+    };
+
+    template<typename It>
+    template<typename Cntnr>
+    void
+    modify_test<It>::
+    operator()(Cntnr)
+    {
+      typedef typename Cntnr::value_type value_type;
+      typedef typename Cntnr::container_category container_category;
+      typedef typename Cntnr::const_reference const_reference;
+      typedef detail::timing_test_base timing_test_base;
+      typedef detail::push_functor<It, Cntnr, container_category> psh_fnct;
+      typedef detail::push_modify_functor<It, Cntnr, container_category> psh_mod_fnct;
+      typedef xml_result_set_performance_formatter formatter_type;
+      formatter_type res_set_fmt(string_form<Cntnr>::name(),
+				 string_form<Cntnr>::desc());
+
+      for (size_t i = 0; m_ins_vn + i * m_ins_vs < m_ins_vm; ++i)
+	{
+	  const size_t v = m_ins_vn + i * m_ins_vs;
+	  It b = m_ins_b;
+	  It e = m_ins_b;
+	  std::advance(e, v);
+
+	  psh_fnct psh_fn(b, e);
+	  const double psh_res = timing_test_base::operator()(psh_fn);
+
+	  value_type val = b->first;
+	  {
+            Cntnr mod_val_container;
+            for (It mod_val_it = b; mod_val_it != e; ++mod_val_it)
+	      {
+                value_type pot = mod_val_it->first;
+                if (m_modify_up == mod_val_container.get_cmp_fn()(val, pot))
+		  val = pot;
+	      }
+	  }
+
+	  psh_mod_fnct psh_mod_fn(b, e, val);
+	  const double psh_mod_res = timing_test_base::operator()(psh_mod_fn);
+
+	  const double min_res = double(timing_test_base::min_time_res());
+	  const double effective_delta = std::max(psh_mod_res - psh_res,
+						  min_res);
+
+	  res_set_fmt.add_res(v, effective_delta / v);
+	}
+    }
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif
+
diff --git a/libstdc++-v3/testsuite/util/performance/priority_queue/timing/push_pop_test.hpp b/libstdc++-v3/testsuite/util/performance/priority_queue/timing/push_pop_test.hpp
new file mode 100644
index 000000000..d3a9a736e
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/priority_queue/timing/push_pop_test.hpp
@@ -0,0 +1,141 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 push_pop_test.hpp
+ * Contains a push performance test.
+ */
+
+#ifndef PB_DS_PUSH_TEST_HPP
+#define PB_DS_PUSH_TEST_HPP
+
+#include <performance/time/timing_test_base.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <performance/io/xml_formatter.hpp>
+#include <common_type/priority_queue/string_form.hpp>
+#include <iterator>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      template<typename It, class Cntnr>
+      class push_pop_push_pop_functor
+      {
+      public:
+        push_pop_push_pop_functor(It ins_it_b,  It ins_it_e) 
+	: m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  for (std::size_t i = 0; i < resolution; ++i)
+	    {
+	      Cntnr cntnr;
+	      for (It ins_it = m_ins_it_b; ins_it != m_ins_it_e; ++ins_it)
+                cntnr.push((typename Cntnr::const_reference)(ins_it->first));
+	      while (!cntnr.empty())
+                cntnr.pop();
+	    }
+	}
+
+      private:
+	const It m_ins_it_b;
+	const It m_ins_it_e;
+      };
+
+    } // namespace detail
+
+    template<typename It>
+    class push_pop_test : private __gnu_pbds::test::detail::timing_test_base
+    {
+    public:
+      push_pop_test(It ins_b, size_t ins_vn, size_t ins_vs, size_t ins_vm)
+      : m_ins_b(ins_b), m_ins_vn(ins_vn), m_ins_vs(ins_vs), m_ins_vm(ins_vm)
+      { }
+
+      template<typename Cntnr>
+      void
+      operator()(Cntnr);
+
+    private:
+      push_pop_test(const push_pop_test&);
+
+      template<typename Cntnr>
+      void
+      push(Cntnr, It ins_it_b, It ins_it_e)
+      {
+	Cntnr cntnr;
+	for (It ins_it = ins_it_b; ins_it != ins_it_e; ++ins_it)
+	  cntnr.push((typename Cntnr::const_reference)(*ins_it));
+      }
+
+      const It m_ins_b;
+      const size_t m_ins_vn;
+      const size_t m_ins_vs;
+      const size_t m_ins_vm;
+    };
+
+ 
+    template<typename It>
+    template<typename Cntnr>
+    void
+    push_pop_test<It>::
+    operator()(Cntnr)
+    {
+      typedef xml_result_set_performance_formatter formatter_type;
+      formatter_type res_set_fmt(string_form<Cntnr>::name(), 
+				 string_form<Cntnr>::desc());
+ 
+      for (size_t i = 0; m_ins_vn + i * m_ins_vs < m_ins_vm; ++i)
+	{
+	  const size_t v = m_ins_vn + i * m_ins_vs;
+	  It ins_it_b = m_ins_b;
+	  It ins_it_e = m_ins_b;
+	  std::advance(ins_it_e, v);
+
+	  __gnu_pbds::test::detail::push_pop_push_pop_functor<It, Cntnr>
+            fn(ins_it_b, ins_it_e);
+
+	  const double res =
+            __gnu_pbds::test::detail::timing_test_base::operator()(fn);
+
+	  res_set_fmt.add_res(v, res / v);
+	}
+    }
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
+
diff --git a/libstdc++-v3/testsuite/util/performance/priority_queue/timing/push_test.hpp b/libstdc++-v3/testsuite/util/performance/priority_queue/timing/push_test.hpp
new file mode 100644
index 000000000..b398a7549
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/priority_queue/timing/push_test.hpp
@@ -0,0 +1,144 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 push_test.hpp
+ * Contains a push performance test.
+ */
+
+#ifndef PB_DS_PUSH_TEST_HPP
+#define PB_DS_PUSH_TEST_HPP
+
+#include <performance/time/timing_test_base.hpp>
+#include <ext/pb_ds/detail/type_utils.hpp>
+#include <performance/io/xml_formatter.hpp>
+#include <common_type/priority_queue/string_form.hpp>
+#include <iterator>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      template<typename It, class Cntnr>
+      class push_push_functor
+      {
+      public:
+        push_push_functor(It ins_it_b,  It ins_it_e) 
+	: m_ins_it_b(ins_it_b), m_ins_it_e(ins_it_e)
+	{ }
+
+	void
+        operator()(std::size_t resolution)
+	{
+	  for (std::size_t i = 0; i < resolution; ++i)
+	    {
+	      Cntnr cntnr;
+	      for (It ins_it = m_ins_it_b; ins_it != m_ins_it_e; ++ins_it)
+                cntnr.push((typename Cntnr::const_reference)(ins_it->first));
+	    }
+	}
+
+      private:
+	const It m_ins_it_b;
+	const It m_ins_it_e;
+      };
+    } // namespace detail
+
+    template<typename It>
+    class push_test : private __gnu_pbds::test::detail::timing_test_base
+    {
+    public:
+      push_test(It ins_b, size_t ins_vn, size_t ins_vs, size_t ins_vm)
+      : m_ins_b(ins_b), m_ins_vn(ins_vn), m_ins_vs(ins_vs), m_ins_vm(ins_vm)
+      { }
+
+      template<typename Cntnr>
+      void
+      operator()(Cntnr);
+
+    private:
+      push_test(const push_test& );
+
+      template<typename Cntnr>
+      void
+      push(Cntnr, It ins_it_b, It ins_it_e);
+
+      const It m_ins_b;
+      const size_t m_ins_vn;
+      const size_t m_ins_vs;
+      const size_t m_ins_vm;
+    };
+
+
+    template<typename It>
+    template<typename Cntnr>
+    void
+    push_test<It>::
+    operator()(Cntnr)
+    {
+      typedef xml_result_set_performance_formatter formatter_type;
+      formatter_type res_set_fmt(string_form<Cntnr>::name(),
+				 string_form<Cntnr>::desc());
+
+      for (size_t i = 0; m_ins_vn + i * m_ins_vs < m_ins_vm; ++i)
+	{
+	  const size_t v = m_ins_vn + i * m_ins_vs;
+	  It ins_it_b = m_ins_b;
+	  It ins_it_e = m_ins_b;
+	  std::advance(ins_it_e, v);
+
+	  __gnu_pbds::test::detail::push_push_functor<It, Cntnr>
+            fn(ins_it_b, ins_it_e);
+
+	  const double res =
+            __gnu_pbds::test::detail::timing_test_base::operator()(fn);
+
+	  res_set_fmt.add_res(v, res / v);
+	}
+    }
+
+    template<typename It>
+    template<typename Cntnr>
+    void
+    push_test<It>::
+    push(Cntnr, It ins_it_b, It ins_it_e)
+    {
+      Cntnr cntnr;
+      for (It ins_it = ins_it_b; ins_it != ins_it_e; ++ins_it)
+        cntnr.push((typename Cntnr::const_reference)(*ins_it));
+    }
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
+
diff --git a/libstdc++-v3/testsuite/util/performance/time/elapsed_timer.cc b/libstdc++-v3/testsuite/util/performance/time/elapsed_timer.cc
new file mode 100644
index 000000000..6b46402fe
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/time/elapsed_timer.cc
@@ -0,0 +1,68 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 elapsed_timer.cpp
+ * Contains utilities for tests.
+ */
+
+#include <util/performance/time/elapsed_timer.hpp>
+
+namespace __gnu_pbds
+{
+
+  namespace test
+  {
+
+    elapsed_timer::
+    elapsed_timer()
+    {
+      reset();
+    }
+
+    void
+    elapsed_timer::
+    reset()
+    {
+      m_start = ::clock();
+    }
+
+    elapsed_timer::
+    operator double() const
+    {
+      const clock_t now = ::clock();
+
+      return (((double)now - m_start) / CLOCKS_PER_SEC);
+    }
+
+  } // namespace test
+
+} // namespace __gnu_pbds
diff --git a/libstdc++-v3/testsuite/util/performance/time/elapsed_timer.hpp b/libstdc++-v3/testsuite/util/performance/time/elapsed_timer.hpp
new file mode 100644
index 000000000..5f7937b92
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/time/elapsed_timer.hpp
@@ -0,0 +1,67 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 elapsed_timer.hpp
+ * Contains time utilities for tests.
+ */
+
+#ifndef PB_DS_TEST_TIME_HPP
+#define PB_DS_TEST_TIME_HPP
+
+#include <time.h>
+#include <iosfwd>
+
+namespace __gnu_pbds
+{
+
+  namespace test
+  {
+
+    class elapsed_timer
+    {
+    public:
+      elapsed_timer();
+
+      void
+      reset();
+
+      operator double() const;
+
+    protected:
+      clock_t m_start;
+    };
+
+  } // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_TEST_TIME_HPP
diff --git a/libstdc++-v3/testsuite/util/performance/time/timing_test_base.hpp b/libstdc++-v3/testsuite/util/performance/time/timing_test_base.hpp
new file mode 100644
index 000000000..961583273
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/performance/time/timing_test_base.hpp
@@ -0,0 +1,117 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 timing_test_base.hpp
+ * Contains a base class for timing tests.
+ */
+
+#ifndef PB_DS_TIMING_TEST_BASE_HPP
+#define PB_DS_TIMING_TEST_BASE_HPP
+
+#include <performance/time/elapsed_timer.hpp>
+#include <statistic/result_recorder.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      class timing_test_base
+      {
+      protected:
+	template<typename Functor>
+	double
+	operator()(Functor& fn);
+
+	static double
+        min_time_res();
+
+      private:
+	template<typename Functor>
+	std::size_t
+	get_min_resolution(Functor&);
+
+	template<typename Functor>
+	double
+	run_at_resolution(Functor&, std::size_t);
+      };
+
+      template<typename Functor>
+      double
+      timing_test_base::operator()(Functor& fn)
+      {
+	const std::size_t resolution = get_min_resolution(fn);
+	__gnu_pbds::test::detail::result_recorder<double> rec;
+	double res;
+	do
+	  res = run_at_resolution(fn, resolution);
+	while (rec.add_result(res) == false);
+	res = rec.get_sample_mean() / resolution;
+	return res;
+      }
+
+      double
+      timing_test_base::min_time_res()
+      { return 1e-7; }
+
+      template<typename Functor>
+      std::size_t
+      timing_test_base::get_min_resolution(Functor& fn)
+      {
+	std::size_t guess = 0;
+	const double epsilon_val = min_time_res();
+	double res;
+	do
+	  {
+	    guess = guess * 2 + 1;
+	    res = run_at_resolution(fn, guess);
+	  }
+	while (res < epsilon_val);
+	return guess;
+      }
+
+      template<typename Functor>
+      double
+      timing_test_base::run_at_resolution(Functor& fn, std::size_t resolution)
+      {
+	elapsed_timer res;
+	fn(resolution);
+	return res;
+      }
+
+    } // namespace detail
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
+
diff --git a/libstdc++-v3/testsuite/util/regression/basic_type.hpp b/libstdc++-v3/testsuite/util/regression/basic_type.hpp
new file mode 100644
index 000000000..9fe6ef24d
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/regression/basic_type.hpp
@@ -0,0 +1,94 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 basic_type.hpp
+ * Contains a type used for regression tests' key and data.
+ */
+
+#ifndef PB_DS_BASIC_TYPE_HPP
+#define PB_DS_BASIC_TYPE_HPP
+
+#include <string>
+#include <ext/throw_allocator.h>
+
+namespace __gnu_pbds
+{
+namespace test
+{
+#define PB_DS_BASE_C_DEC \
+  std::basic_string<char, std::char_traits<char>, \
+		    __gnu_cxx::throw_allocator_random<char> >
+
+  struct basic_type : public PB_DS_BASE_C_DEC
+  {
+  private:
+    typedef PB_DS_BASE_C_DEC base_type;
+
+  public:
+    enum
+      {
+	distinct_chars = 4
+      };
+
+    basic_type() { }
+
+    template<typename Gen>
+    basic_type(Gen& r_gen, size_t max)
+    {
+      size_t rnd = r_gen.get_unsigned_long(0, static_cast<unsigned long>(max));
+      while (rnd > 0)
+	{
+	  base_type::push_back('a' + static_cast<char>(rnd % distinct_chars));
+	  rnd /= distinct_chars;
+	}
+    }
+
+    basic_type(const std::string other)
+    {
+      std::string::const_iterator it = other.begin();
+      while (it != other.end())
+	{
+	  base_type::push_back(*it);
+	  ++it;
+	}
+    }
+
+    operator std::string() const
+    { return std::string(base_type::c_str());}
+  };
+
+#undef PB_DS_BASE_C_DEC
+
+} // namespace test
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/libstdc++-v3/testsuite/util/regression/common_type.hpp b/libstdc++-v3/testsuite/util/regression/common_type.hpp
new file mode 100644
index 000000000..37705bc2d
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/regression/common_type.hpp
@@ -0,0 +1,194 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2008, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 <vector>
+#include <regression/basic_type.hpp>
+#include <common_type/assoc/common_type.hpp>
+#include <common_type/priority_queue/common_type.hpp>
+
+namespace __gnu_pbds
+{
+namespace test
+{
+  typedef __gnu_cxx::throw_allocator_random<basic_type> alloc_type;
+
+  struct hash
+  {
+    typedef alloc_type::rebind<basic_type>::other basic_type_rebind;
+    typedef basic_type_rebind::const_reference const_reference;
+    typedef basic_type::const_iterator const_iterator;
+
+    size_t
+    operator()(const_reference r_key) const
+    {
+      size_t ret = 0;
+      for (const_iterator it = r_key.begin(); it != r_key.end(); ++it)
+	ret = ret * 5 + static_cast<size_t>(*it);
+      return ret;
+    }
+  };
+
+  typedef __gnu_pbds::string_trie_e_access_traits<basic_type, 'a', 'a' + basic_type::distinct_chars - 1, false, alloc_type> e_access_traits_t;
+
+  template<typename Data_Type>
+  struct tree_types
+  {
+  private:
+    typedef typename tree_common_types<basic_type, Data_Type, std::less<basic_type>, __gnu_pbds::null_tree_node_update, alloc_type>::regression_tl no_order_statistics_tl_t;
+
+    typedef typename tree_common_types<basic_type, Data_Type, std::less<basic_type>, __gnu_pbds::tree_order_statistics_node_update, alloc_type>::regression_tl order_statistics_tl_t;
+
+  public:
+    typedef typename __gnu_cxx::typelist::append<no_order_statistics_tl_t, order_statistics_tl_t>::type tl_t;
+
+    typedef no_order_statistics_tl_t min_tl_t;
+  };
+
+  template<typename Data_Type>
+  struct trie_types
+  {
+  private:
+    typedef typename trie_common_types<basic_type, Data_Type, e_access_traits_t, __gnu_pbds::pat_trie_tag, __gnu_pbds::null_trie_node_update, alloc_type>::regression_tl no_updates_tl_t;
+
+    typedef typename trie_common_types<basic_type, Data_Type, e_access_traits_t, __gnu_pbds::pat_trie_tag, __gnu_pbds::trie_order_statistics_node_update, alloc_type>::regression_tl order_statistics_tl_t;
+
+    typedef typename trie_common_types<basic_type, Data_Type, e_access_traits_t, __gnu_pbds::pat_trie_tag, __gnu_pbds::trie_prefix_search_node_update, alloc_type>::regression_tl prefix_search_tl_t;
+
+  public:
+    typedef typename __gnu_cxx::typelist::append<no_updates_tl_t, typename __gnu_cxx::typelist::append<prefix_search_tl_t, order_statistics_tl_t>::type>::type tl_t;
+
+    typedef no_updates_tl_t min_tl_t;
+  };
+
+  template<typename Data_Type>
+  struct hash_types
+  {
+    typedef typename hash_common_types<basic_type, Data_Type, hash, std::equal_to<basic_type>, alloc_type>::regression_tl tl_t;
+
+    typedef tl_t min_tl_t;
+  };
+
+  template<typename Data_Type>
+  struct lu_types
+  {
+    typedef typename lu_common_types<basic_type, Data_Type, std::equal_to<basic_type>, alloc_type>::regression_tl tl_t;
+
+  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;
+  typedef tree_types<basic_type>::min_tl_t 		min_tree_map_tl_t;
+
+  typedef hash_types<null_mapped_type>::tl_t 		hash_set_tl_t;
+  typedef hash_types<null_mapped_type>::min_tl_t 	min_hash_set_tl_t;
+  typedef hash_types<basic_type>::tl_t 			hash_map_tl_t;
+  typedef hash_types<basic_type>::min_tl_t 		min_hash_map_tl_t;
+
+  typedef lu_types<null_mapped_type>::tl_t 		lu_set_tl_t;
+  typedef lu_types<null_mapped_type>::min_tl_t 		min_lu_set_tl_t;
+  typedef lu_types<basic_type>::tl_t 			lu_map_tl_t;
+  typedef lu_types<basic_type>::min_tl_t 		min_lu_map_tl_t;
+
+  typedef trie_types<null_mapped_type>::tl_t 		trie_set_tl_t;
+  typedef trie_types<null_mapped_type>::min_tl_t 	min_trie_set_tl_t;
+  typedef trie_types<basic_type>::tl_t 			trie_map_tl_t;
+  typedef trie_types<basic_type>::min_tl_t 		min_trie_map_tl_t;
+} // namespace test
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/libstdc++-v3/testsuite/util/regression/rand/assoc/container_rand_regression_test.h b/libstdc++-v3/testsuite/util/regression/rand/assoc/container_rand_regression_test.h
new file mode 100644
index 000000000..ca4433212
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/regression/rand/assoc/container_rand_regression_test.h
@@ -0,0 +1,475 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2008, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 <ext/pb_ds/assoc_container.hpp>
+#include <io/prog_bar.hpp>
+#include <testsuite_rng.h>
+#include <regression/trait/assoc/trait.hpp>
+#include <common_type/assoc/string_form.hpp>
+#include <regression/rand/xml_formatter.hpp>
+
+namespace __gnu_pbds
+{
+namespace test
+{
+namespace detail
+{
+  // Rand test specialized for a specific container.
+  template<typename Cntnr>
+  class container_rand_regression_test
+  {
+  public:
+
+    container_rand_regression_test(unsigned long, size_t, size_t, double, 
+				   double, double, double, double, bool);
+
+    virtual
+    ~container_rand_regression_test();
+
+    void
+    operator()();
+
+  private:
+    typedef Cntnr 					cntnr;
+    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::const_key_reference	const_key_reference;
+    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_cxx::throw_allocator_random<char>    	alloc_t;
+
+    enum op
+      {
+	insert_op,
+	erase_op,
+	clear_op,
+	other_op
+      };
+
+    op
+    get_next_op();
+
+    size_t
+    get_next_sub_op(size_t);
+
+    static void
+    defs();
+
+    static void
+    key_defs();
+
+    static void
+    mapped_defs();
+
+    static void
+    value_defs();
+
+    static void
+    ds_defs();
+
+    static void
+    iterator_defs();
+
+    static void
+    node_iterator_defs(__gnu_pbds::detail::false_type);
+
+    static void
+    node_iterator_defs(__gnu_pbds::detail::true_type);
+
+    static void
+    policy_defs();
+
+    static void
+    policy_defs(__gnu_pbds::basic_hash_tag);
+
+    static void
+    policy_defs(__gnu_pbds::cc_hash_tag);
+
+    static void
+    policy_defs(__gnu_pbds::gp_hash_tag);
+
+    static void
+    policy_defs(__gnu_pbds::tree_tag);
+
+    static void
+    policy_defs(__gnu_pbds::list_update_tag);
+
+    static void
+    policy_defs(__gnu_pbds::pat_trie_tag);
+
+    void
+    policy_access();
+
+    void
+    policy_access(__gnu_pbds::basic_hash_tag);
+
+    void
+    policy_access(__gnu_pbds::cc_hash_tag);
+
+    void
+    policy_access(__gnu_pbds::gp_hash_tag);
+
+    void
+    policy_access(__gnu_pbds::tree_tag);
+
+    void
+    policy_access(__gnu_pbds::list_update_tag);
+
+    void
+    policy_access(__gnu_pbds::pat_trie_tag);
+
+    void
+    it_copy();
+
+    void
+    it_assign();
+
+    void
+    rev_it_copy();
+
+    void
+    rev_it_assign();
+
+    void
+    rev_it_copy_imp(__gnu_pbds::detail::false_type);
+
+    void
+    rev_it_copy_imp(__gnu_pbds::detail::true_type);
+
+    void
+    rev_it_assign_imp(__gnu_pbds::detail::false_type);
+
+    void
+    rev_it_assign_imp(__gnu_pbds::detail::true_type);
+
+    bool
+    default_constructor();
+
+    void
+    swap();
+
+    bool
+    copy_constructor();
+
+    bool
+    assignment_operator();
+
+    bool
+    it_constructor();
+
+    bool
+    it_constructor_imp(__gnu_pbds::cc_hash_tag);
+
+    bool
+    it_constructor_imp(__gnu_pbds::gp_hash_tag);
+
+    bool
+    it_constructor_imp(__gnu_pbds::tree_tag);
+
+    bool
+    it_constructor_imp(__gnu_pbds::list_update_tag);
+
+    bool
+    it_constructor_imp(__gnu_pbds::pat_trie_tag);
+
+    bool
+    insert();
+
+    bool
+    erase();
+
+    bool
+    erase_it();
+
+    bool
+    erase_it_imp(__gnu_pbds::detail::false_type);
+
+    bool
+    erase_it_imp(__gnu_pbds::detail::true_type);
+
+    bool
+    erase_rev_it();
+
+    bool
+    erase_rev_it_imp(__gnu_pbds::detail::false_type);
+
+    bool
+    erase_rev_it_imp(__gnu_pbds::detail::true_type);
+
+    bool
+    erase_if();
+
+    bool
+    clear();
+
+    bool
+    resize();
+
+    bool
+    resize_imp(__gnu_pbds::detail::true_type);
+
+    bool
+    resize_imp(__gnu_pbds::detail::false_type);
+
+    bool
+    get_set_loads();
+
+    bool
+    get_set_loads_imp(__gnu_pbds::detail::true_type);
+
+    bool
+    get_set_loads_imp(__gnu_pbds::detail::false_type);
+
+    void
+    get_set_load();
+
+    void
+    get_set_load_imp(__gnu_pbds::detail::true_type);
+
+    void
+    get_set_load_imp(__gnu_pbds::detail::false_type);
+
+    bool
+    subscript();
+
+    bool
+    subscript_imp(__gnu_pbds::detail::false_type);
+
+    bool
+    subscript_imp(__gnu_pbds::detail::true_type);
+
+    bool
+    split_join();
+
+    bool
+    split_join_imp(__gnu_pbds::detail::false_type);
+
+    bool
+    split_join_imp(__gnu_pbds::detail::true_type);
+
+    void
+    cmp(const Cntnr&, const native_type&, const std::string&);
+
+    void
+    basic_cmp_(const Cntnr&, const native_type&);
+
+    void
+    cmp_(const Cntnr&, const native_type&);
+
+    void
+    order_preserving_cmp_imp(const Cntnr&, const native_type&, 
+			     __gnu_pbds::detail::false_type);
+
+    void
+    order_preserving_cmp_imp(const Cntnr&, const native_type&, 
+			     __gnu_pbds::detail::true_type);
+
+    void
+    back_order_preserving_cmp_imp(const Cntnr&, const native_type&, 
+				  __gnu_pbds::detail::false_type);
+
+    void
+    back_order_preserving_cmp_imp(const Cntnr&, const native_type&, 
+				  __gnu_pbds::detail::true_type);
+
+    void
+    reverse_iteration_cmp_imp(const Cntnr&, const native_type&, 
+			      __gnu_pbds::detail::false_type);
+
+    void
+    reverse_iteration_cmp_imp(const Cntnr&, const native_type&, 
+			      __gnu_pbds::detail::true_type);
+
+    void
+    order_statistics_cmp_imp(const Cntnr&, const native_type&, 
+			     __gnu_pbds::detail::false_type);
+
+    void
+    order_statistics_cmp_imp(const Cntnr&, const native_type&, 
+			     __gnu_pbds::detail::true_type);
+
+    void
+    prefix_search_cmp_imp(const Cntnr&, const native_type&, 
+			  __gnu_pbds::detail::false_type);
+
+    void
+    prefix_search_cmp_imp(const Cntnr&, const native_type&, 
+			  __gnu_pbds::detail::true_type);
+
+    template<typename Const_It, class Const_Native_It>
+    void
+    it_cmp_imp(Const_It, Const_It, Const_Native_It, Const_Native_It);
+
+    template<typename Const_It, class Const_Native_It>
+    void
+    back_it_cmp_imp(Const_It, Const_It, Const_Native_It, Const_Native_It);
+
+    void
+    lower_bound_cmp_imp(const Cntnr&, const native_type&, 
+			__gnu_pbds::detail::false_type);
+
+    void
+    lower_bound_cmp_imp(const Cntnr&, const native_type&, 
+			__gnu_pbds::detail::true_type);
+
+    void
+    upper_bound_cmp_imp(const Cntnr&, const native_type&, 
+			__gnu_pbds::detail::false_type);
+
+    void
+    upper_bound_cmp_imp(const Cntnr&, const native_type&, 
+			__gnu_pbds::detail::true_type);
+
+    void
+    print_container(const native_type&, std::ostream& r_os = std::cerr) const;
+
+    void
+    print_container(const cntnr&, std::ostream& r_os = std::cerr) const;
+
+    struct destructor_printer
+    {
+      destructor_printer(const std::string& r_msg) 
+      : m_msg(r_msg), m_print(true) { }
+
+      void
+      cancel_print()
+      { m_print = false; }
+
+      ~destructor_printer()
+      {
+	if (!m_print)
+	  return;
+
+	std::cerr << std::endl << "Uncaught exception: " << std::endl 
+		  << m_msg << std::endl;
+      }
+
+    private:
+      const std::string m_msg;
+      bool m_print;
+    };
+
+    const unsigned long 	m_seed;
+    const size_t 		m_n;
+    const size_t 		m_m;
+    const double 		m_tp;
+    const double 		m_ip;
+    const double 		m_ep;
+    const double 		m_cp;
+    const double 		m_mp;
+    const bool 			m_disp;
+    twister_rand_gen 		m_g;
+    Cntnr* 			m_p_c;
+    native_type 		m_native_c;
+    alloc_t 			m_alloc;
+    size_t 			m_i;
+  };
+
+#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
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+#undef PB_DS_THROW_IF_FAILED_
+#undef PB_DS_THROW_IF_FAILED
+#undef PB_DS_SET_DESTRUCT_PRINT
+#undef PB_DS_CANCEL_DESTRUCT_PRINT
+#undef PB_DS_TRACE
+
+} // namespace detail
+} // namespace test
+} // namespace __gnu_pbds
+
+#endif
diff --git a/libstdc++-v3/testsuite/util/regression/rand/assoc/container_rand_regression_test.tcc b/libstdc++-v3/testsuite/util/regression/rand/assoc/container_rand_regression_test.tcc
new file mode 100644
index 000000000..0f1586648
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/regression/rand/assoc/container_rand_regression_test.tcc
@@ -0,0 +1,2133 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2008, 2009, 2010 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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(0)
+{ }
+
+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_probability(m_tp);
+
+  try
+    {
+      m_p_c = new Cntnr;
+    }
+  catch(__gnu_cxx::forced_error&)
+    {
+      done = false;
+    }
+
+  if (m_p_c)
+    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_probability(0);
+  Cntnr* p_c = new Cntnr;
+  m_alloc.set_probability(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 = 0;
+  m_alloc.set_probability(m_tp);
+  typename alloc_t::group_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_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 = 0;
+  m_alloc.set_probability(m_tp);
+  typename alloc_t::group_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_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 = 0;
+  m_alloc.set_probability(m_tp);
+  typename alloc_t::group_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_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 = 0;
+  m_alloc.set_probability(m_tp);
+  typename alloc_t::group_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_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 = 0;
+  m_alloc.set_probability(m_tp);
+  typename alloc_t::group_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_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 = 0;
+  m_alloc.set_probability(m_tp);
+  typename alloc_t::group_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_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 = 0;
+  m_alloc.set_probability(m_tp);
+  typename alloc_t::group_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_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_probability(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_probability(0);
+      const key_type k = native_key;
+      m_alloc.set_probability(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_probability(0);
+    const key_type k = test_traits::generate_key(m_g, m_m);
+    m_alloc.set_probability(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_probability(0);
+  const key_type k = test_traits::generate_key(m_g, m_m);
+  m_alloc.set_probability(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_probability(0);
+  const key_type k = test_traits::generate_key(m_g, m_m);
+  m_alloc.set_probability(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_probability(0);
+  const key_type k = test_traits::generate_key(m_g, m_m);
+  m_alloc.set_probability(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 = 0;
+
+  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.seed(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_probability(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_probability(0);
+      value_type v = test_traits::generate_value(m_g, m_m);
+      m_alloc.set_probability(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_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_probability(0);
+      value_type v = test_traits::generate_value(m_g, m_m);
+
+      m_alloc.set_probability(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_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_probability(0);
+      value_type v = test_traits::generate_value(m_g, m_m);
+      m_alloc.set_probability(m_tp);
+      (*m_p_c)[v] = __gnu_pbds::null_mapped_type();
+      m_native_c.insert(test_traits::native_value(v));
+    }
+  catch(__gnu_cxx::forced_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_probability(0);
+  const key_type k = test_traits::generate_key(m_g, m_m);
+  m_alloc.set_probability(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_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_probability(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_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_probability(0);
+      const key_type k = test_traits::generate_key(m_g, m_m);
+      m_alloc.set_probability(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_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_probability(0);      
+      const key_type k = test_traits::generate_key(m_g, m_m);      
+      m_alloc.set_probability(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_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);
+  }
+  {
+    const typename Cntnr::hash_fn& r_t =((const Cntnr& )*m_p_c).get_hash_fn();
+    assert(&r_t);
+  }
+
+  {
+    typename Cntnr::eq_fn& r_t = m_p_c->get_eq_fn();
+    assert(&r_t);
+  }
+  {
+    const typename Cntnr::eq_fn& r_t =((const Cntnr& )*m_p_c).get_eq_fn();
+    assert(&r_t);
+  }
+
+  {
+    typename Cntnr::resize_policy& r_t = m_p_c->get_resize_policy();
+    assert(&r_t);
+  }
+  {
+    const typename Cntnr::resize_policy& r_t =((const Cntnr& )*m_p_c).get_resize_policy();
+
+    assert(&r_t);
+  }
+}
+
+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);
+  }
+  {
+    const typename Cntnr::comb_hash_fn& r_t =((const Cntnr& )*m_p_c).get_comb_hash_fn();
+
+    assert(&r_t);
+  }
+}
+
+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);
+  }
+  {
+    const typename Cntnr::comb_probe_fn& r_t =((const Cntnr& )*m_p_c).get_comb_probe_fn();
+
+    assert(&r_t);
+  }
+
+  {
+    typename Cntnr::probe_fn& r_t = m_p_c->get_probe_fn();
+    assert(&r_t);
+  }
+  {
+    const typename Cntnr::probe_fn& r_t =((const Cntnr& )*m_p_c).get_probe_fn();
+    assert(&r_t);
+  }
+}
+
+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);
+  }
+
+  {
+    const typename Cntnr::cmp_fn& r_t =((const Cntnr& )*m_p_c).get_cmp_fn();
+    assert(&r_t);
+  }
+}
+
+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);
+}
+
+
+// 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_probability(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_probability(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_probability(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_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_probability(m_tp);
+      typename alloc_t::group_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_probability(1);
+  typename alloc_t::group_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_probability(m_tp);
+
+      typename alloc_t::group_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_probability(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_probability(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
diff --git a/libstdc++-v3/testsuite/util/regression/rand/assoc/rand_regression_test.hpp b/libstdc++-v3/testsuite/util/regression/rand/assoc/rand_regression_test.hpp
new file mode 100644
index 000000000..5f2304952
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/regression/rand/assoc/rand_regression_test.hpp
@@ -0,0 +1,198 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009, 2010 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 rand_regression_test.hpp
+ * Contains a random-operation test.
+ */
+
+#ifndef PB_DS_ASSOC_RAND_REGRESSION_TEST_HPP
+#define PB_DS_ASSOC_RAND_REGRESSION_TEST_HPP
+
+#include <iostream>
+#include <vector>
+#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/common_type.hpp>
+
+namespace __gnu_pbds
+{
+namespace test
+{
+namespace detail
+{
+#ifndef PB_DS_REGRESSION
+#error "Must define PB_DS_REGRESSION"
+#endif
+
+  struct rand_reg_test
+  {
+  public:
+    rand_reg_test(size_t seed, size_t n, size_t m, double tp, double ip, 
+		  double ep, double cp, double mp, bool d) 
+    : m_sd(seed), m_n(n), m_m(m), m_tp(tp), m_ip(ip), m_ep(ep), m_cp(cp), 
+      m_mp(mp), m_disp(d)
+    { }
+
+    template<typename Cntnr>
+    void
+    operator()(Cntnr)
+    {
+      unsigned long ul = static_cast<unsigned long>(m_sd);
+      container_rand_regression_test<Cntnr> t(ul, m_n, m_n, m_tp, m_ip, 
+					      m_ep, m_cp, m_mp, m_disp);
+      t();
+    }
+
+  private:
+    const size_t m_sd;
+    const size_t m_n;
+    const size_t m_m;
+    const double m_tp;
+    const double m_ip;
+    const double m_ep;
+    const double m_cp;
+    const double m_mp;
+    const bool m_disp;
+  };
+
+  void
+  usage(const std::string& r_name);
+
+  void
+  verify_params(size_t&, size_t&, size_t&, 
+		double&, double&, double&, double&, double&, bool&);
+} // namespace detail
+
+  template<typename TL>
+  int
+  rand_regression_test(size_t iter, size_t keys, const std::string name, TL tl)
+  {
+    // Sane defaults.
+    size_t n = iter;
+    size_t m = keys;
+    size_t sd = twister_rand_gen::get_time_determined_seed();
+    double tp = 0.2;
+    double ip = 0.6;
+    double ep = 0.2; 
+    double cp = 0.001;
+    double mp = 0.25;
+    bool disp = false; // show progress
+
+    try
+      {
+	detail::verify_params(sd, n, m, tp, ip, ep, cp, mp, disp);
+      }
+    catch (__gnu_pbds::test::illegal_input_error&)
+      {
+	detail::usage(name);
+	return -1;
+      }
+    catch (...)
+      {
+	return -2;
+      };
+
+    // XXX RAII, constructor takes bool for display
+    xml_test_rand_regression_formatter* p_fmt = 0;
+    if (disp)
+      p_fmt = new xml_test_rand_regression_formatter(sd, n, m, tp, ip, ep, cp, mp);
+
+    try
+      {
+	detail::rand_reg_test tst(sd, n, m, tp, ip, ep, cp, mp, disp);
+	__gnu_cxx::typelist::apply(tst, tl);
+      }
+    catch (...)
+      {
+	std::cerr << "Test failed with seed " << sd << std::endl;
+	if (disp)
+	  delete p_fmt;
+	throw;
+      }
+
+    if (disp)
+      delete p_fmt;
+    return 0;
+  }
+
+namespace detail
+{
+  inline void
+  usage(const std::string& name)
+  {
+    using namespace std;
+    cerr << "usage: " << name << " <sd> <n> <m> <tp> <ip> <ep> <cp> <mp> ['t' | 'f']" <<
+      endl << endl;
+
+    cerr << "This test performs basic regression tests on various associative containers."
+      "For each container, it performs a sequence of operations. At each iteration, it does "
+      "the following: " << endl;
+    cerr << "*  Performs an operation on the container " << endl;
+    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";
+
+    cerr << endl << 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;
+    cerr << "ip = probability that an operation will be insert" << endl;
+    cerr << "ep = probability that an operation will be erase" << endl;
+    cerr << "cp = probability that an operation will be clear" << endl;
+    cerr << "(therefore, 1 - (ip + ep + cp) = probability of any other operation)" << endl;
+    cerr << "mp = probability that the container will be compared to the cntnr object" << endl;
+    cerr << "'t' or 'f' determine whether progress will be displayed" << endl;
+  }
+
+  inline void
+  verify_params(size_t& r_seed, size_t& r_n, 
+		size_t& r_m, double& r_tp, double& r_ip, double& r_ep, 
+		double& r_cp, double& r_mp, bool& r_d)
+  {
+    verify_prob(r_tp);
+    verify_prob(r_ip);
+    verify_prob(r_ep);
+    verify_prob(r_cp);
+    verify_prob(r_mp);
+    verify_prob(r_ip + r_ep + r_cp);
+  }
+} // namespace detail
+} // namespace test
+} // namespace __gnu_pbds
+
+#endif
diff --git a/libstdc++-v3/testsuite/util/regression/rand/priority_queue/container_rand_regression_test.h b/libstdc++-v3/testsuite/util/regression/rand/priority_queue/container_rand_regression_test.h
new file mode 100644
index 000000000..828541ce7
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/regression/rand/priority_queue/container_rand_regression_test.h
@@ -0,0 +1,265 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2008, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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;
+      typedef regression_test_traits<cntnr> 			test_traits;
+
+      enum op
+	{
+	  insert_op,
+	  modify_op,
+	  erase_op,
+	  clear_op,
+	  other_op
+	};
+
+      op
+      get_next_op();
+
+      size_t
+      get_next_sub_op(size_t max);
+
+      static void
+      defs();
+
+      static void
+      value_defs();
+
+      static void
+      ds_defs();
+
+      static void
+      iterator_defs();
+
+      static void
+      policy_defs();
+
+      void
+      policy_access();
+
+      void
+      it_copy();
+
+      void
+      it_assign();
+
+      bool
+      default_constructor();
+
+      void
+      swap();
+
+      bool
+      copy_constructor();
+
+      bool
+      assignment_operator();
+
+      bool
+      it_constructor();
+
+      bool
+      push();
+
+      bool
+      modify();
+
+      bool
+      pop();
+
+      bool
+      erase_if();
+
+      bool
+      erase_it();
+
+      bool
+      clear();
+
+      bool
+      split_join();
+
+      void
+      cmp(const Cntnr& r_container, const native_type& r_native_c, 
+	  const std::string& r_call_fn);
+
+      void
+      print_container(const native_type& r_cnt, 
+		      std::ostream& r_os = std::cerr) const;
+
+      void
+      print_container(const cntnr& r_cnt, 
+		      std::ostream& r_os = std::cerr) const;
+
+      struct destructor_printer
+      {
+	destructor_printer(const std::string& r_msg) 
+	: m_msg(r_msg), m_print(true) { }
+
+	void
+	cancel()
+	{ m_print = false; }
+
+	~destructor_printer()
+	{
+	  if (m_print)
+	    {
+	      std::cerr << std::endl << "Uncaught exception: " << std::endl 
+			<< m_msg << std::endl;
+	    }
+	}
+
+	const std::string 	m_msg;
+	bool 			m_print;
+      };
+
+      const unsigned long 	m_seed;
+      const size_t 		m_n;
+      const size_t 		m_m;
+      const double 		m_tp;
+      const double 		m_ip;
+      const double 		m_dp;
+      const double 		m_ep;
+      const double 		m_cp;
+      const double 		m_mp;
+      const bool 		m_disp;
+      twister_rand_gen 		m_g;
+      Cntnr* 			m_p_c;
+      native_type 		m_native_c;
+      allocator_type 		m_alloc;
+      size_t 			m_i;
+
+    public:
+      container_rand_regression_test(unsigned long seed, size_t n, size_t m, 
+				     double tp, double ip, double dp, 
+				     double ep, double cp, double mp, 
+				     bool disp);
+
+      virtual
+      ~container_rand_regression_test();
+      
+      void
+      operator()();
+  };
+
+
+#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 _GLIBCXX_THROW_IF_(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("pbds throw if failed");		\
+	}
+
+#define _GLIBCXX_THROW_IF(PRED, MORE, P_C, P_NC)			\
+      _GLIBCXX_THROW_IF_(PRED, MORE, P_C, P_NC, __FILE__, __LINE__)
+
+#include <regression/rand/priority_queue/container_rand_regression_test.tcc>
+
+#undef PB_DS_COND_COMPARE
+#undef PB_DS_RUN_MTHD
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+#undef _GLIBCXX_THROW_IF_
+#undef _GLIBCXX_THROW_IF
+#undef PB_DS_TRACE
+
+} // namespace detail
+} // namespace test
+} // namespace __gnu_pbds
+
+#endif
diff --git a/libstdc++-v3/testsuite/util/regression/rand/priority_queue/container_rand_regression_test.tcc b/libstdc++-v3/testsuite/util/regression/rand/priority_queue/container_rand_regression_test.tcc
new file mode 100644
index 000000000..e929f3533
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/regression/rand/priority_queue/container_rand_regression_test.tcc
@@ -0,0 +1,838 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2008, 2009, 2010 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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
+
+  // Constructor, copy constructor, assignment and destructor.
+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 dp, 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_dp(dp), m_ep(ep), m_cp(cp),
+  m_mp(mp), m_disp(disp), m_p_c(0)
+{ }
+
+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_probability(m_tp);
+
+  try
+    {
+      m_p_c = new Cntnr;
+    }
+  catch(__gnu_cxx::forced_error&)
+    {
+      done = false;
+    }
+
+  if (m_p_c)
+    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_probability(0);
+  Cntnr* p_c = new Cntnr;
+  m_alloc.set_probability(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 = 0;
+  m_alloc.set_probability(m_tp);
+
+  typedef typename allocator_type::group_adjustor adjustor;
+  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_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 = 0;
+  m_alloc.set_probability(m_tp);
+
+  typedef typename allocator_type::group_adjustor adjustor;
+  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_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()
+{
+  bool done = true;
+  Cntnr* p_c = 0;
+  m_alloc.set_probability(m_tp);
+  typedef typename allocator_type::group_adjustor adjustor;
+  adjustor adjust(m_p_c->size());
+
+  try
+    {
+      switch(get_next_sub_op(3))
+        {
+        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());
+	  break;
+        case 2:
+	  p_c = new Cntnr(m_p_c->begin(), m_p_c->end(), m_p_c->get_cmp_fn());
+	  break;
+        default:
+	  _GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);
+        };
+
+      std::swap(p_c, m_p_c);
+    }
+  catch(__gnu_cxx::forced_error&)
+    {
+      done = false;
+    }
+
+  delete p_c;
+  PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+  return done;
+}
+
+
+  // Compare.
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+cmp(const Cntnr& c, const native_type& native, const std::string& callfn)
+{
+  destructor_printer notify(__FUNCTION__);
+
+  try
+    {
+      m_alloc.set_probability(1);
+      
+      const size_t size = c.size();
+      const size_t native_size = native.size();
+      _GLIBCXX_THROW_IF(size != native_size, size << " " << native_size,
+			&c, &native);
+      
+      const bool empty = c.empty();
+      const bool native_empty = native.empty();
+      _GLIBCXX_THROW_IF(empty != native_empty, empty << " " << native_empty, 
+			&c, &native);
+      
+      const size_t it_size = std::distance(c.begin(), c.end());
+      _GLIBCXX_THROW_IF(it_size != size, it_size << " " << size, &c, &native);
+      
+      if (!c.empty())
+	{
+	  const std::string native_top = native.top();
+	  const std::string top = test_traits::native_value(c.top());
+	  const bool top_smaller = std::less<std::string>()(top, native_top);
+	  const bool top_larger = std::less<std::string>()(native_top, top);
+	  
+	  if (top_smaller || top_larger)
+	    _GLIBCXX_THROW_IF(true, top << " " << native_top, &c, &native);
+	}
+    }
+  catch(...)
+    {
+      _GLIBCXX_THROW_IF(true, "call-fn: " + callfn, &c, &native);
+    }
+  
+  notify.cancel();
+}
+
+  // 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 = 0;
+  if (m_disp)
+    p_fmt = new formatter_type(string_form<Cntnr>::name(),
+			       string_form<Cntnr>::desc());
+
+  m_g.init(m_seed);
+  m_alloc.seed(m_seed);
+
+  // The __throw_allocator::_S_label defaults to 0, so to make things
+  // easier and more precise when debugging, start at 1.
+  const size_t starting_label(1);
+
+  try
+    {
+      prog_bar pb(m_n, std::cout, m_disp);
+
+      for (m_i = starting_label; m_i <= m_n; ++m_i)
+        {
+	  PB_DS_TRACE("Op #" << m_i);
+
+	  // Track allocation from this point only.
+	  allocator_type::set_label(m_i);
+	  switch(m_i)
+            {
+            case 1:
+	      PB_DS_RUN_MTHD(default_constructor);
+	      break;
+            case 2:
+	      defs();
+	      break;
+            case 3:
+	      policy_access();
+	      break;
+            case 4:
+	      it_copy();
+	      break;
+            case 5:
+	      it_assign();
+	      break;
+            default:
+	      switch(get_next_op())
+                {
+                case insert_op:
+		  PB_DS_RUN_MTHD(push)
+                    break;
+                case modify_op:
+		  PB_DS_RUN_MTHD(modify)
+                    break;
+                case erase_op:
+		  switch(get_next_sub_op(3))
+                    {
+                    case 0:
+		      PB_DS_RUN_MTHD(pop)
+                        break;
+                    case 1:
+		      PB_DS_RUN_MTHD(erase_if)
+                        break;
+                    case 2:
+		      PB_DS_RUN_MTHD(erase_it)
+                        break;
+                    default:
+		      _GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);
+                    }
+		  break;
+                case clear_op:
+		  PB_DS_RUN_MTHD(clear)
+                    break;
+                case other_op:
+		  switch(get_next_sub_op(5))
+                    {
+                    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;
+                    default:
+		      _GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);
+                    }
+		  break;
+                default:
+		  _GLIBCXX_THROW_IF(true, "", m_p_c,  &m_native_c);
+                };
+            }
+	  pb.inc();
+        }
+    }
+  catch (...)
+    {
+      std::cerr << "Failed at index " << m_i << std::endl;
+      delete m_p_c;
+      throw;
+    }
+
+  // Clean up, then check for allocation by special label, set above.
+  allocator_type::set_label(0);
+  delete m_p_c;
+
+  try 
+    { 
+      for (size_t n = starting_label; n <= m_n; ++n)
+	m_alloc.check_allocated(n); 
+    }
+  catch (std::logic_error& obj)
+    {
+      // On fail, check_allocated should throw std::logic_error.
+      std::cerr << obj.what() << std::endl;
+      std::cerr << typeid(Cntnr).name() << std::endl;
+      throw;
+    }
+
+  // Reset throw probability.
+  m_alloc.set_probability(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_dp)
+    return modify_op;
+
+  if (prob < m_ip + m_dp + m_ep)
+    return erase_op;
+
+  if (prob < m_ip + m_dp + m_ep + m_cp)
+    return clear_op;
+
+  _GLIBCXX_THROW_IF(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)
+      {
+	_GLIBCXX_THROW_IF(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::
+push()
+{
+  PB_DS_TRACE("push");
+  bool done = true;
+  destructor_printer notify(__FUNCTION__);
+
+    try
+      {
+        m_alloc.set_probability(0);
+        value_type v = test_traits::generate_value(m_g, m_m);
+        m_alloc.set_probability(m_tp);
+        const typename cntnr::size_type sz = m_p_c->size();
+        m_p_c->push(v);
+        _GLIBCXX_THROW_IF(sz != m_p_c->size() - 1, sz, m_p_c, &m_native_c);
+        m_native_c.push(test_traits::native_value(v));
+      }
+    catch(__gnu_cxx::forced_error&)
+      {
+        done = false;
+      }
+    catch(...)
+      {
+        _GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);
+      }
+
+  PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+  notify.cancel();
+  return done;
+}
+
+
+  // Modify.
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+modify()
+{
+  PB_DS_TRACE("modify");
+  destructor_printer notify(__FUNCTION__);
+
+  bool done = true;
+  try
+    {
+      m_alloc.set_probability(0);
+      value_type v = test_traits::generate_value(m_g, m_m);
+
+      m_alloc.set_probability(m_tp);
+      typename cntnr::iterator it = m_p_c->begin();
+      std::advance(it, m_g.get_unsigned_long(0, m_p_c->size()));
+      if (it != m_p_c->end())
+	{
+	  typedef typename test_traits::native_value_type native_value_type;
+	  native_value_type native_v = test_traits::native_value(*it);
+	  native_value_type new_native_v = test_traits::native_value(v);
+	  m_p_c->modify(it, v);
+	  m_native_c.modify(native_v, new_native_v);
+	}
+    }
+  catch(__gnu_cxx::forced_error&)
+    {
+      done = false;
+      _GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);
+    }
+
+  PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+  notify.cancel();
+  return done;
+}
+
+  // Clear.
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+clear()
+{
+  PB_DS_TRACE("clear");
+  m_p_c->clear();
+  m_native_c.clear();
+  return true;
+}
+
+  // Erase.
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+pop()
+{
+  PB_DS_TRACE("pop");
+  destructor_printer notify(__FUNCTION__);
+
+  bool done = true;
+  try
+    {
+      m_alloc.set_probability(1);
+      if (!m_p_c->empty())
+        {
+	  m_p_c->pop();
+	  m_native_c.pop();
+        }
+    }
+  catch(__gnu_cxx::forced_error&)
+    {
+      done = false;
+      _GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);
+    }
+
+  PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+  notify.cancel();
+  return done;
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+erase_if()
+{
+  PB_DS_TRACE("erase_if");
+  destructor_printer notify(__FUNCTION__);
+
+  bool done = true;
+  try
+    {
+      typedef
+	typename std::iterator_traits<typename cntnr::iterator>::reference
+	it_const_reference;
+      
+      m_alloc.set_probability(1);
+      
+      typedef
+	typename test_traits::template erase_if_fn<value_type>
+	erase_if_fn_t;
+      
+      const size_t ersd = m_p_c->erase_if(erase_if_fn_t());
+      
+      typedef
+	typename test_traits::template erase_if_fn<std::string>
+	native_erase_if_fn_t;
+      
+      const size_t native_ersd = m_native_c.erase_if(native_erase_if_fn_t());
+
+      _GLIBCXX_THROW_IF(ersd != native_ersd, ersd << " " << native_ersd,
+			m_p_c, &m_native_c);
+    }
+  catch(__gnu_cxx::forced_error&)
+    {
+      done = false;      
+      _GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);
+    }
+
+  PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+  notify.cancel();
+  return done;
+}
+
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+erase_it()
+{
+  PB_DS_TRACE("erase_it");
+  destructor_printer notify(__FUNCTION__);
+
+  bool done = true;
+  try
+    {
+      m_alloc.set_probability(1);      
+      typename cntnr::iterator it = m_p_c->begin();      
+      std::advance(it, m_g.get_unsigned_long(0, m_p_c->size()));
+      
+      if (it != m_p_c->end())
+	{
+	  m_native_c.erase(*it);	 
+	  m_p_c->erase(it);
+	}
+    }
+  catch(__gnu_cxx::forced_error&)
+    {
+      done = false;      
+      _GLIBCXX_THROW_IF(true, "", m_p_c, &m_native_c);
+    }
+
+  PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+  notify.cancel();
+  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;
+  value_defs();
+  iterator_defs();
+  policy_defs();
+}
+
+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 typename Cntnr::container_category test_container_category;
+}
+
+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::
+policy_defs()
+{
+  typedef typename Cntnr::allocator_type test_allocator;
+  typedef typename Cntnr::cmp_fn test_cmp_fn;
+}
+
+
+// Policy access.
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+policy_access()
+{
+  PB_DS_TRACE("policy_access");
+
+  {
+    typename Cntnr::cmp_fn& r_t = m_p_c->get_cmp_fn();
+    assert(&r_t);
+  }
+
+  {
+    const typename Cntnr::cmp_fn& r_t =((const Cntnr& )*m_p_c).get_cmp_fn();
+    assert(&r_t);
+  }
+}
+
+// Split join.
+PB_DS_CLASS_T_DEC
+bool
+PB_DS_CLASS_C_DEC::
+split_join()
+{
+  PB_DS_TRACE("split_join");
+  destructor_printer notify(__FUNCTION__);
+
+  bool done = true;
+  try
+    {
+      m_alloc.set_probability(0);
+      Cntnr lhs(*m_p_c);
+      Cntnr rhs;
+      native_type native_lhs(m_native_c);
+      m_alloc.set_probability(m_tp);
+      
+      typedef typename test_traits::template erase_if_fn<value_type> split_fn_t;
+      lhs.split(split_fn_t(), rhs);
+      
+      typedef typename test_traits::template erase_if_fn<std::string>
+	native_split_fn_t;
+      
+      native_type native_rhs;      
+      native_lhs.split(native_split_fn_t(), native_rhs);      
+      PB_DS_COND_COMPARE(lhs, native_lhs);
+      PB_DS_COND_COMPARE(rhs, native_rhs);
+      
+      m_alloc.set_probability(m_tp);
+      
+      if (m_g.get_prob() < 0.5)
+	lhs.swap(rhs);      
+      lhs.join(rhs);
+      
+      _GLIBCXX_THROW_IF(rhs.size() != 0, rhs.size(), m_p_c, &m_native_c);
+      _GLIBCXX_THROW_IF(!rhs.empty(), rhs.size(), m_p_c, &m_native_c);
+    }
+  catch(__gnu_cxx::forced_error&)
+    {
+      done = false;      
+      const bool b = __gnu_pbds::container_traits<cntnr>::split_join_can_throw;
+      _GLIBCXX_THROW_IF(!b, b, m_p_c, &m_native_c);
+    }
+  
+  PB_DS_COND_COMPARE(*m_p_c, m_native_c);
+  notify.cancel();
+  return done;
+}
+
+// Iterator conversions.
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+it_copy()
+{
+  PB_DS_TRACE("it_copy");
+
+  {
+    typename cntnr::iterator it = m_p_c->end();
+    typename cntnr::const_iterator const_it(it);
+    _GLIBCXX_THROW_IF(const_it != it, "", m_p_c, &m_native_c);
+    _GLIBCXX_THROW_IF(!(const_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);
+    _GLIBCXX_THROW_IF(const_find_it != const_it, "", m_p_c, &m_native_c);
+    _GLIBCXX_THROW_IF(!(const_find_it == const_it), "", m_p_c, &m_native_c);
+  }
+
+  {
+    typename cntnr::iterator it = m_p_c->end();
+    typename cntnr::const_point_iterator const_find_it1(it);
+    _GLIBCXX_THROW_IF(const_find_it1 != it, "", m_p_c, &m_native_c);
+    _GLIBCXX_THROW_IF(!(const_find_it1 == it), "", m_p_c, &m_native_c);
+
+    typename cntnr::point_iterator find_it1(it);
+    _GLIBCXX_THROW_IF(find_it1 != it, "", m_p_c, &m_native_c);
+    _GLIBCXX_THROW_IF(!(find_it1 == 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);
+    _GLIBCXX_THROW_IF(find_it != const_find_it, "", m_p_c, &m_native_c);
+    _GLIBCXX_THROW_IF(!(find_it == const_find_it), "", m_p_c, &m_native_c);
+  }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+it_assign()
+{
+  PB_DS_TRACE("it_assign");
+
+  {
+    typename cntnr::iterator it = m_p_c->end();
+    typename cntnr::const_iterator const_it;
+    const_it = it;
+    _GLIBCXX_THROW_IF(const_it != it, "", m_p_c, &m_native_c);
+    _GLIBCXX_THROW_IF(!(const_it == it), "", m_p_c, &m_native_c);
+
+    typename cntnr::const_point_iterator const_find_it;
+    const_find_it = it;
+    _GLIBCXX_THROW_IF(const_find_it != it, "", m_p_c, &m_native_c);
+    _GLIBCXX_THROW_IF(!(const_find_it == it), "", m_p_c, &m_native_c);
+
+    typename cntnr::point_iterator find_it;
+    find_it = it;
+    _GLIBCXX_THROW_IF(find_it != it, "", m_p_c, &m_native_c);
+    _GLIBCXX_THROW_IF(!(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;
+    _GLIBCXX_THROW_IF(const_find_it != const_it, "", m_p_c, &m_native_c);
+    _GLIBCXX_THROW_IF(!(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;
+    _GLIBCXX_THROW_IF(find_it != const_find_it, "", m_p_c, &m_native_c);
+    _GLIBCXX_THROW_IF(!(find_it == const_find_it), "", m_p_c, &m_native_c);
+  }
+}
+
+
+// Diagnostics.
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+print_container(const native_type& cnt, std::ostream& os) const
+{
+  m_alloc.set_probability(0);
+  native_type cpy(cnt);
+  while (!cpy.empty())
+    {
+      os << cpy.top() << std::endl;
+      cpy.pop();
+    }
+}
+
+PB_DS_CLASS_T_DEC
+void
+PB_DS_CLASS_C_DEC::
+print_container(const cntnr& cnt, std::ostream& os) const
+{
+  typedef typename cntnr::const_iterator const_iterator;
+  m_alloc.set_probability(0);
+  for (const_iterator it = cnt.begin(); it != cnt.end(); ++it)
+    os << *it << std::endl;
+}
+
+#endif
diff --git a/libstdc++-v3/testsuite/util/regression/rand/priority_queue/rand_regression_test.hpp b/libstdc++-v3/testsuite/util/regression/rand/priority_queue/rand_regression_test.hpp
new file mode 100644
index 000000000..37f8d51af
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/regression/rand/priority_queue/rand_regression_test.hpp
@@ -0,0 +1,202 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2008, 2009, 2010 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 rand_regression_test.hpp
+ * Contains a random-operation test.
+ */
+
+#ifndef PB_DS_PQ_RAND_REGRESSION_TEST_HPP
+#define PB_DS_PQ_RAND_REGRESSION_TEST_HPP
+
+#include <iostream>
+#include <vector>
+#include <io/verified_cmd_line_input.hpp>
+#include <regression/common_type.hpp>
+#include <regression/rand/priority_queue/container_rand_regression_test.h>
+
+namespace __gnu_pbds
+{
+namespace test
+{
+namespace detail
+{
+#ifndef PB_DS_REGRESSION
+#error "Must define PB_DS_REGRESSION"
+#endif
+
+  struct rand_reg_test
+  {
+  public:
+    rand_reg_test(size_t seed, size_t n, size_t m, double tp, double ip, 
+		  double dp, double ep, double cp, double mp, bool d) 
+    : m_sd(seed), m_n(n), m_m(m), m_tp(tp), m_ip(ip), m_dp(dp), m_ep(ep), 
+      m_cp(cp), m_mp(mp), m_disp(d)
+    { }
+
+    template<typename Cntnr>
+    void
+    operator()(Cntnr)
+    {
+      unsigned long ul = static_cast<unsigned long>(m_sd);
+      container_rand_regression_test<Cntnr> t(ul, m_n, m_n, m_tp, m_ip, m_dp, 
+					      m_ep, m_cp, m_mp, m_disp);
+      t();
+    }
+
+  private:
+    const size_t m_sd;
+    const size_t m_n;
+    const size_t m_m;
+    const double m_tp;
+    const double m_ip;
+    const double m_dp;
+    const double m_ep;
+    const double m_cp;
+    const double m_mp;
+    const bool m_disp;
+  };
+
+  void
+  usage(const std::string& r_name);
+
+  void
+  verify_params(size_t&, size_t&, size_t&, 
+		double&, double&, double&, double&, double&, double&, bool&);
+} // namespace detail
+
+  template<typename TL>
+  int
+  rand_regression_test(size_t iter, size_t keys, const std::string name, TL tl)
+  {
+    // Sane defaults.
+    size_t n = iter;
+    size_t m = keys;
+    size_t sd = 0; // 0 = time-determined arbitrary
+    double tp = 0.2;
+    double ip = 0.6;
+    double dp = 0.1;
+    double ep = 0.2; 
+    double cp = 0.001;
+    double mp = 1;
+    bool disp = false; // show progress
+
+    try
+      {
+	detail::verify_params(sd, n, m, tp, ip, dp, ep, cp, mp, disp);
+      }
+    catch(__gnu_pbds::test::illegal_input_error&)
+      {
+	detail::usage(name);
+	return -1;
+      }
+    catch(...)
+      {
+	return -2;
+      };
+
+    xml_test_rand_regression_formatter* p_fmt = 0;
+    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, dp,
+						     ep, cp, mp);
+
+    try
+      {
+	detail::rand_reg_test tst(sd, n, m, tp, ip, dp, ep, cp, mp, disp);
+	__gnu_cxx::typelist::apply(tst, tl);
+      }
+    catch(...)
+      {
+	std::cerr << "Test failed with seed " << sd << std::endl;
+	if (disp)
+	  delete p_fmt;
+	return -1;
+      }
+
+    if (disp)
+      delete p_fmt;
+    return 0;
+  }
+
+namespace detail
+{
+  inline void
+  usage(const std::string& name)
+  {
+    using namespace std;
+    cerr << "usage: " << name << " <sd> <n> <m> <tp> <ip> <dp> <ep> <cp> <mp> ['t' | 'f']" <<
+      endl << endl;
+
+    cerr << "This test performs basic regression tests on various priority queues."
+      "For each container, it performs a sequence of operations. At each iteration, it does "
+      "the following: " << endl;
+    cerr << "*  Performs an operation on the container " << endl;
+    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";
+
+    cerr << endl << 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;
+    cerr << "ip = probability that an operation will be insert" << endl;
+    cerr << "dp = probability that an operation will be modify" << endl;
+    cerr << "ep = probability that an operation will be erase" << endl;
+    cerr << "cp = probability that an operation will be clear" << endl;
+    cerr << "(therefore, 1 - (ip + dp + ep + cp) = probability of any other operation)" << endl;
+    cerr << "mp = probability that the container will be compared to the cntnr object" << endl;
+    cerr << "'t' or 'f' determine whether progress will be displayed" << endl;
+  }
+
+  inline void
+  verify_params(size_t& r_seed, size_t& r_n, 
+		size_t& r_m, double& r_tp, double& r_ip, double& r_dp, 
+		double& r_ep, double& r_cp, double& r_mp, bool& r_d)
+  {
+    verify_prob(r_tp);
+    verify_prob(r_ip);
+    verify_prob(r_dp);
+    verify_prob(r_ep);
+    verify_prob(r_cp);
+    verify_prob(r_mp);
+    verify_prob(r_ip + r_dp + r_ep + r_cp);
+  }
+} // namespace detail
+} // namespace test
+} // namespace __gnu_pbds
+
+#endif
diff --git a/libstdc++-v3/testsuite/util/regression/rand/xml_formatter.hpp b/libstdc++-v3/testsuite/util/regression/rand/xml_formatter.hpp
new file mode 100644
index 000000000..5dca782c5
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/regression/rand/xml_formatter.hpp
@@ -0,0 +1,100 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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_COMMON_XML_TEST_REGRESSION_FORMATTER_HPP
+#define PB_DS_COMMON_XML_TEST_REGRESSION_FORMATTER_HPP
+
+#include <string>
+#include <iostream>
+#include <io/xml_test_formatter.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    // Test formatters.
+    struct xml_test_rand_regression_formatter : public xml_test_formatter
+    {
+      // Associative.
+      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);
+      }
+
+      // Priority Queue.
+      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);
+      }
+    };
+
+    // Result formatter.
+    struct xml_result_set_regression_formatter : public xml_result_set_formatter
+    {
+      xml_result_set_regression_formatter(const std::string& r_container_name, 
+					  const std::string& r_container_desc)
+      : xml_result_set_formatter(r_container_name, r_container_desc)
+      {	
+	std::cout << detail::make_xml_name_start_tag("progress");
+	std::cout << detail::make_xml_name_start_tag_end_delimiter();
+      }
+
+      ~xml_result_set_regression_formatter()
+      { std::cout << detail::make_xml_name_end_tag("progress"); }      
+    };
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_COMMON_XML_TEST_REGRESSION_FORMATTER_HPP
diff --git a/libstdc++-v3/testsuite/util/regression/trait/assoc/get_set_load_trait.hpp b/libstdc++-v3/testsuite/util/regression/trait/assoc/get_set_load_trait.hpp
new file mode 100644
index 000000000..b771b8020
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/regression/trait/assoc/get_set_load_trait.hpp
@@ -0,0 +1,90 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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_trait.hpp
+ * Contains traits for a random regression test
+ *    for a specific container type.
+ */
+
+#ifndef PB_DS_REGRESSION_TEST_SET_LOAD_TRAIT_HPP
+#define PB_DS_REGRESSION_TEST_SET_LOAD_TRAIT_HPP
+
+#include <ext/pb_ds/assoc_container.hpp>
+
+namespace __gnu_pbds
+{
+
+  namespace test
+  {
+
+    namespace detail
+    {
+
+      template<typename Cntnr, class Tag>
+      struct regression_test_get_set_load_traits
+      {
+	enum
+	  {
+	    value = false
+	  };
+      };
+
+      template<typename Cntnr>
+      struct regression_test_hash_get_set_load_traits
+      {
+	enum
+	  {
+	    value = Cntnr::resize_policy::trigger_policy::get_set_load
+	  };
+      };
+
+      template<typename Cntnr>
+      struct regression_test_get_set_load_traits<
+        Cntnr,
+        __gnu_pbds::cc_hash_tag> : public regression_test_hash_get_set_load_traits<
+        Cntnr>
+      { };
+
+      template<typename Cntnr>
+      struct regression_test_get_set_load_traits<
+        Cntnr,
+        __gnu_pbds::gp_hash_tag> : public regression_test_hash_get_set_load_traits<
+        Cntnr>
+      { };
+
+    } // namespace detail
+
+  } // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_REGRESSION_TEST_SET_LOAD_TRAIT_HPP
diff --git a/libstdc++-v3/testsuite/util/regression/trait/assoc/get_set_loads_trait.hpp b/libstdc++-v3/testsuite/util/regression/trait/assoc/get_set_loads_trait.hpp
new file mode 100644
index 000000000..6d7508da8
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/regression/trait/assoc/get_set_loads_trait.hpp
@@ -0,0 +1,90 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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_trait.hpp
+ * Contains traits for a random regression test
+ *    for a specific container type.
+ */
+
+#ifndef PB_DS_REGRESSION_TEST_SET_LOADS_TRAIT_HPP
+#define PB_DS_REGRESSION_TEST_SET_LOADS_TRAIT_HPP
+
+#include <ext/pb_ds/assoc_container.hpp>
+
+namespace __gnu_pbds
+{
+
+  namespace test
+  {
+
+    namespace detail
+    {
+
+      template<typename Cntnr, class Tag>
+      struct regression_test_get_set_loacontainer_traits
+      {
+	enum
+	  {
+	    value = false
+	  };
+      };
+
+      template<typename Cntnr>
+      struct regression_test_hash_get_set_loacontainer_traits
+      {
+	enum
+	  {
+	    value = Cntnr::resize_policy::trigger_policy::get_set_loads
+	  };
+      };
+
+      template<typename Cntnr>
+      struct regression_test_get_set_loacontainer_traits<
+        Cntnr,
+        __gnu_pbds::cc_hash_tag> : public regression_test_hash_get_set_loacontainer_traits<
+        Cntnr>
+      { };
+
+      template<typename Cntnr>
+      struct regression_test_get_set_loacontainer_traits<
+        Cntnr,
+        __gnu_pbds::gp_hash_tag> : public regression_test_hash_get_set_loacontainer_traits<
+        Cntnr>
+      { };
+
+    } // namespace detail
+
+  } // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_REGRESSION_TEST_SET_LOADS_TRAIT_HPP
diff --git a/libstdc++-v3/testsuite/util/regression/trait/assoc/native_type_trait.hpp b/libstdc++-v3/testsuite/util/regression/trait/assoc/native_type_trait.hpp
new file mode 100644
index 000000000..38761a177
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/regression/trait/assoc/native_type_trait.hpp
@@ -0,0 +1,185 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 native_type_trait.hpp
+ * Contains traits for a random regression test
+ *    for a specific container type.
+ */
+
+#ifndef PB_DS_REGRESSION_TEST_NATIVE_TYPE_TRAIT_HPP
+#define PB_DS_REGRESSION_TEST_NATIVE_TYPE_TRAIT_HPP
+
+namespace __gnu_pbds
+{
+
+  namespace test
+  {
+
+    namespace detail
+    {
+
+      template<typename Key, class Allocator>
+      struct native_key_type;
+
+      template<typename Allocator>
+      struct native_key_type<
+	basic_type,
+	Allocator>
+      {
+	typedef std::string type;
+
+	static type
+        native_key(typename Allocator::template rebind<
+		   basic_type>::other::const_reference r_key)
+	{
+	  return (std::string(r_key));
+	}
+      };
+
+      template<typename Hd, class Tl, class Allocator>
+      struct native_key_type<
+	std::pair<
+        Hd,
+        Tl>,
+	Allocator>
+      {
+	typedef typename native_key_type< Hd, Allocator>::type hd_type;
+
+	typedef typename native_key_type< Tl, Allocator>::type tl_type;
+
+	typedef std::pair< hd_type, tl_type> type;
+
+	static type
+        native_key(typename Allocator::template rebind<            std::pair<Hd, Tl> >::other::const_reference r_key)
+	{
+	  return (std::make_pair(
+				 native_key_type<Hd, Allocator>::native_key(r_key.first),
+				 native_key_type<Tl, Allocator>::native_key(r_key.second)));
+	}
+      };
+
+      template<typename Native_Key_Type,
+	       class Key_Type,
+	       class Data_Type,
+	       class Allocator>
+      struct native_type_traits_base;
+
+      template<typename Native_Key_Type, class Key_Type, class Allocator>
+      struct native_type_traits_base<
+	Native_Key_Type,
+	Key_Type,
+	basic_type,
+	Allocator>
+      {
+      public:
+	typedef std::map< Native_Key_Type, std::string> type;
+
+      public:
+	static const typename type::key_type& 
+        extract_key(typename type::const_reference r_val)
+	{
+	  return (r_val.first);
+	}
+
+	static typename type::value_type
+        native_value(typename Allocator::template rebind<            std::pair<Key_Type, basic_type> >::other::const_reference r_val)
+	{
+	  return (std::make_pair(
+				 native_key_type<Key_Type, Allocator>::native_key(r_val.first),
+				 std::string(r_val.second)));
+	}
+      };
+
+      template<typename Native_Key_Type, class Key_Type, class Allocator>
+      struct native_type_traits_base<
+	Native_Key_Type,
+	Key_Type,
+	__gnu_pbds::null_mapped_type,
+	Allocator>
+      {
+      public:
+	typedef std::set< Native_Key_Type> type;
+
+      public:
+	static const typename type::key_type& 
+        extract_key(typename type::const_reference r_val)
+	{
+	  return (r_val);
+	}
+
+	static typename type::value_type
+        native_value(typename Allocator::template rebind<
+		     Key_Type>::other::const_reference r_val)
+	{
+	  return (native_key_type<Key_Type, Allocator>::native_key(
+								   r_val));
+	}
+      };
+
+#define PB_DS_NATIVE_KEY_TYPE_C_DEC				\
+      native_key_type<						\
+						Key_Type,	\
+						Allocator>
+
+#define PB_DS_BASE_C_DEC						\
+      native_type_traits_base<						\
+									typename PB_DS_NATIVE_KEY_TYPE_C_DEC::type, \
+									Key_Type, \
+									Data_Type, \
+									Allocator>
+
+      template<typename Key_Type, class Data_Type, class Allocator>
+      struct native_type_traits : public PB_DS_BASE_C_DEC
+      {
+	typedef typename PB_DS_BASE_C_DEC::type type;
+
+	typedef typename type::key_type key_type;
+
+	static typename PB_DS_NATIVE_KEY_TYPE_C_DEC::type
+        native_key(typename Allocator::template rebind<
+		   Key_Type>::other::const_reference r_key)
+	{
+	  return (PB_DS_NATIVE_KEY_TYPE_C_DEC::native_key(r_key));
+	}
+      };
+
+#undef PB_DS_BASE_C_DEC
+
+#undef PB_DS_NATIVE_KEY_TYPE_C_DEC
+
+    } // namespace detail
+
+  } // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_REGRESSION_TEST_NATIVE_TYPE_TRAIT_HPP
diff --git a/libstdc++-v3/testsuite/util/regression/trait/assoc/node_update_trait.hpp b/libstdc++-v3/testsuite/util/regression/trait/assoc/node_update_trait.hpp
new file mode 100644
index 000000000..d971c1fb2
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/regression/trait/assoc/node_update_trait.hpp
@@ -0,0 +1,124 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 node_update_trait.hpp
+ * Contains traits for a random regression test
+ *    for a specific container type.
+ */
+
+#ifndef PB_DS_REGRESSION_TEST_NODE_UPDATOR_TRAIT_HPP
+#define PB_DS_REGRESSION_TEST_NODE_UPDATOR_TRAIT_HPP
+
+#include <ext/pb_ds/assoc_container.hpp>
+#include <common_type/assoc/detail/tree_supports_order_statistics.hpp>
+#include <common_type/assoc/detail/trie_supports_order_statistics.hpp>
+#include <common_type/assoc/detail/trie_supports_prefix_search.hpp>
+
+namespace __gnu_pbds
+{
+
+  namespace test
+  {
+
+    namespace detail
+    {
+
+      template<typename Cntnr, class Tag>
+      struct regression_test_node_update_traits
+      {
+	enum
+	  {
+	    order_statistics = false,
+	    prefix_search = false
+	  };
+      };
+
+      template<typename Cntnr>
+      struct regression_test_node_update_traits<
+	Cntnr,
+	__gnu_pbds::pat_trie_tag>
+      {
+	enum
+	  {
+	    order_statistics =
+            trie_supports_order_statistics<Cntnr>::value,
+	    prefix_search =
+            trie_supports_prefix_search<Cntnr>::value
+	  };
+      };
+
+      template<typename Cntnr>
+      struct regression_test_node_update_traits<
+	Cntnr,
+	__gnu_pbds::rb_tree_tag>
+      {
+	enum
+	  {
+	    order_statistics =
+            tree_supports_order_statistics<Cntnr>::value,
+	    prefix_search = false
+	  };
+      };
+
+      template<typename Cntnr>
+      struct regression_test_node_update_traits<
+	Cntnr,
+	__gnu_pbds::splay_tree_tag>
+      {
+	enum
+	  {
+	    order_statistics =
+            tree_supports_order_statistics<Cntnr>::value,
+	    prefix_search = false
+	  };
+      };
+
+      template<typename Cntnr>
+      struct regression_test_node_update_traits<
+	Cntnr,
+	__gnu_pbds::ov_tree_tag>
+      {
+	enum
+	  {
+	    order_statistics =
+            tree_supports_order_statistics<Cntnr>::value,
+	    prefix_search = false
+	  };
+      };
+
+    } // namespace detail
+
+  } // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_REGRESSION_TEST_NODE_UPDATOR_TRAIT_HPP
diff --git a/libstdc++-v3/testsuite/util/regression/trait/assoc/resize_trait.hpp b/libstdc++-v3/testsuite/util/regression/trait/assoc/resize_trait.hpp
new file mode 100644
index 000000000..51e012775
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/regression/trait/assoc/resize_trait.hpp
@@ -0,0 +1,90 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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_trait.hpp
+ * Contains traits for a random regression test
+ *    for a specific container type.
+ */
+
+#ifndef PB_DS_REGRESSION_TEST_RESIZE_TRAIT_HPP
+#define PB_DS_REGRESSION_TEST_RESIZE_TRAIT_HPP
+
+#include <ext/pb_ds/assoc_container.hpp>
+
+namespace __gnu_pbds
+{
+
+  namespace test
+  {
+
+    namespace detail
+    {
+
+      template<typename Cntnr, class Tag>
+      struct regression_test_resize_traits
+      {
+	enum
+	  {
+	    value = false
+	  };
+      };
+
+      template<typename Cntnr>
+      struct regression_test_hash_resize_traits
+      {
+	enum
+	  {
+	    value = Cntnr::resize_policy::external_size_access
+	  };
+      };
+
+      template<typename Cntnr>
+      struct regression_test_resize_traits<
+        Cntnr,
+        __gnu_pbds::cc_hash_tag> : public regression_test_hash_resize_traits<
+        Cntnr>
+      { };
+
+      template<typename Cntnr>
+      struct regression_test_resize_traits<
+        Cntnr,
+        __gnu_pbds::gp_hash_tag> : public regression_test_hash_resize_traits<
+        Cntnr>
+      { };
+
+    } // namespace detail
+
+  } // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_REGRESSION_TEST_RESIZE_TRAIT_HPP
diff --git a/libstdc++-v3/testsuite/util/regression/trait/assoc/to_string.hpp b/libstdc++-v3/testsuite/util/regression/trait/assoc/to_string.hpp
new file mode 100644
index 000000000..7a1a2e305
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/regression/trait/assoc/to_string.hpp
@@ -0,0 +1,81 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 to_string.hpp
+ * Contains classes for transforming stuff to strings.
+ */
+
+#ifndef PB_DS_REGRESSION_TEST_TO_STRING_HPP
+#define PB_DS_REGRESSION_TEST_TO_STRING_HPP
+
+#include <regression/basic_type.hpp>
+#include <string>
+
+namespace __gnu_pbds
+{
+
+  namespace test
+  {
+
+    namespace detail
+    {
+
+      std::string
+      to_string(const basic_type& r_t)
+      {
+	return (r_t);
+      }
+
+      std::string
+      to_string(const std::string& r_t)
+      {
+	return (r_t);
+      }
+
+      template<typename Hd, class Tl>
+      std::string
+      to_string(const std::pair<Hd, Tl>&r_t)
+      {
+	std::ostringstream ret;
+
+	ret << to_string(r_t.first) << " " << to_string(r_t.second);
+
+	return (ret.str());
+      }
+
+    } // namespace detail
+
+  } // namespace test
+
+} // namespace __gnu_pbds
+
+#endif // #ifndef PB_DS_REGRESSION_TEST_TO_STRING_HPP
diff --git a/libstdc++-v3/testsuite/util/regression/trait/assoc/trait.hpp b/libstdc++-v3/testsuite/util/regression/trait/assoc/trait.hpp
new file mode 100644
index 000000000..a4a768e5e
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/regression/trait/assoc/trait.hpp
@@ -0,0 +1,206 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 trait.hpp
+ * Contains traits for a random regression test
+ *    for a specific container type.
+ */
+
+#ifndef PB_DS_REGRESSION_TEST_TRAIT_HPP
+#define PB_DS_REGRESSION_TEST_TRAIT_HPP
+
+#include <regression/trait/erase_if_fn.hpp>
+#include <regression/trait/assoc/to_string.hpp>
+#include <regression/trait/assoc/type_trait.hpp>
+#include <regression/trait/assoc/native_type_trait.hpp>
+#include <regression/trait/assoc/resize_trait.hpp>
+#include <regression/trait/assoc/get_set_loads_trait.hpp>
+#include <regression/trait/assoc/get_set_load_trait.hpp>
+#include <regression/trait/assoc/node_update_trait.hpp>
+
+namespace __gnu_pbds
+{
+namespace test
+{
+namespace detail
+{
+
+#define PB_DS_CLASS_T_DEC \
+  template<typename Cntnr>
+
+#define PB_DS_CLASS_C_DEC \
+  regression_test_traits<Cntnr>
+
+#define PB_DS_TYPE_TRAITS_C_DEC \
+  regression_test_type_traits<Cntnr>
+
+#define PB_DS_NATIVE_TYPE_TRAITS_C_DEC \
+  native_type_traits<typename PB_DS_TYPE_TRAITS_C_DEC::key_type, \
+		     typename PB_DS_TYPE_TRAITS_C_DEC::mapped_type, \
+		     typename Cntnr::allocator_type>
+
+#define PB_DS_RESIZE_TRAITS_C_DEC \
+  regression_test_resize_traits<Cntnr, typename Cntnr::container_category>
+
+#define PB_DS_SET_LOADS_TRAITS_C_DEC \
+  regression_test_get_set_loacontainer_traits<Cntnr,	\
+					  typename Cntnr::container_category>
+
+#define PB_DS_SET_LOAD_TRAITS_C_DEC \
+  regression_test_get_set_load_traits<Cntnr,typename Cntnr::container_category>
+
+#define PB_DS_NODE_UPDATOR_TRAITS_C_DEC \
+  regression_test_node_update_traits<Cntnr, typename Cntnr::container_category>
+
+  template<typename Cntnr>
+  struct regression_test_traits : private PB_DS_TYPE_TRAITS_C_DEC,
+				  private PB_DS_NATIVE_TYPE_TRAITS_C_DEC,
+				  private PB_DS_RESIZE_TRAITS_C_DEC,
+				  private PB_DS_NODE_UPDATOR_TRAITS_C_DEC,
+				  private PB_DS_SET_LOADS_TRAITS_C_DEC,
+				  private PB_DS_SET_LOAD_TRAITS_C_DEC
+  {
+  private:
+    typedef PB_DS_NATIVE_TYPE_TRAITS_C_DEC native_type_traits_base;
+    typedef PB_DS_TYPE_TRAITS_C_DEC type_traits_base;
+
+  public:
+    typedef typename Cntnr::value_type value_type;
+    typedef typename Cntnr::const_reference const_reference;
+    typedef typename PB_DS_NATIVE_TYPE_TRAITS_C_DEC::type native_type;
+    typedef typename native_type::value_type native_value_type;
+
+    // Only associative containers.
+    typedef typename Cntnr::key_type key_type;
+    typedef typename Cntnr::const_key_reference const_key_reference;
+    typedef typename native_type::key_type native_key_type;
+
+    enum
+      {
+	resize = PB_DS_RESIZE_TRAITS_C_DEC::value,
+	get_set_loads = PB_DS_SET_LOADS_TRAITS_C_DEC::value,
+	get_set_load = PB_DS_SET_LOAD_TRAITS_C_DEC::value,
+	order_statistics = PB_DS_NODE_UPDATOR_TRAITS_C_DEC::order_statistics,
+	prefix_search = PB_DS_NODE_UPDATOR_TRAITS_C_DEC::prefix_search
+      };
+
+    template<typename T>
+    struct erase_if_fn : public regression_test_erase_if_fn<T>
+    { };
+
+    static size_t
+    erase_if(native_type& r_native_c)
+    {
+      typedef regression_test_erase_if_fn<native_value_type> erase_if_fn;
+      typename native_type::iterator it = r_native_c.begin();
+      size_t num_ersd = 0;
+      while (it != r_native_c.end())
+	if (erase_if_fn()(*it))
+	  {
+	    ++num_ersd;
+	    r_native_c.erase(it);
+	    it = r_native_c.begin();
+	  }
+	else
+	  ++it;
+      return num_ersd;
+    }
+
+    static void
+    print_container(const Cntnr& r_c, std::ostream& r_os)
+    { PB_DS_TYPE_TRAITS_C_DEC::print_container(r_c, r_os); }
+
+    template<typename Gen>
+    static key_type
+    generate_key(Gen& r_gen, size_t max)
+    { return PB_DS_TYPE_TRAITS_C_DEC::generate_key(r_gen, max); }
+
+    template<typename Gen>
+    static value_type
+    generate_value(Gen& r_gen, size_t max)
+    { return PB_DS_TYPE_TRAITS_C_DEC::generate_value(r_gen, max); }
+
+    static const_key_reference
+    extract_key(const_reference r_val)
+    { return type_traits_base::extract_key(r_val); }
+
+    static native_key_type
+    native_key(const_key_reference r_key)
+    { return native_type_traits_base::native_key(r_key); }
+
+    static native_value_type
+    native_value(const_reference r_val)
+    { return native_type_traits_base::native_value(r_val); }
+
+    static const native_key_type& 
+    extract_native_key(const native_value_type& r_val)
+    { return native_type_traits_base::extract_key(r_val); }
+
+    static bool
+    cmp(const_reference r_val, const native_value_type& r_native_val)
+    { return val_to_string(r_val) == native_val_to_string(r_native_val); }
+
+    static std::string
+    val_to_string(const_reference r_val)
+    { return to_string(r_val); }
+
+    static std::string
+    key_to_string(const_key_reference r_key)
+    { return to_string(r_key); }
+
+    static std::string
+    native_val_to_string(const native_value_type& r_native_val)
+    { return to_string(r_native_val); }
+
+    static bool
+    prefix_match(const_key_reference r_key, const std::string& r_native_key)
+    {
+      const size_t len = std::min(r_key.length(), r_native_key.length());
+      const std::string substr = r_native_key.substr(0, len);
+      return substr == static_cast<const std::string&>(r_key);
+    }
+  };
+
+#undef PB_DS_TYPE_TRAITS_C_DEC
+#undef PB_DS_NATIVE_TYPE_TRAITS_C_DEC
+#undef PB_DS_RESIZE_TRAITS_C_DEC
+#undef PB_DS_SET_LOADS_TRAITS_C_DEC
+#undef PB_DS_SET_LOAD_TRAITS_C_DEC
+#undef PB_DS_NODE_UPDATOR_TRAITS_C_DEC
+#undef PB_DS_CLASS_T_DEC
+#undef PB_DS_CLASS_C_DEC
+
+} // namespace detail
+} // namespace test
+} // namespace __gnu_pbds
+
+#endif
diff --git a/libstdc++-v3/testsuite/util/regression/trait/assoc/type_trait.hpp b/libstdc++-v3/testsuite/util/regression/trait/assoc/type_trait.hpp
new file mode 100644
index 000000000..c7ce5f7a3
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/regression/trait/assoc/type_trait.hpp
@@ -0,0 +1,111 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 type_trait.hpp
+ * Contains traits for a random regression test
+ *    for a specific container type.
+ */
+
+#ifndef PB_DS_REGRESSION_TEST_TYPE_TRAIT_HPP
+#define PB_DS_REGRESSION_TEST_TYPE_TRAIT_HPP
+
+#include <regression/basic_type.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      template<typename Cntnr>
+      struct regression_test_type_traits
+      {
+	typedef Cntnr cntnr;
+	typedef typename cntnr::key_type key_type;
+	typedef typename cntnr::const_key_reference const_key_reference;
+	typedef typename cntnr::value_type value_type;
+	typedef typename cntnr::const_reference const_reference;
+	typedef typename cntnr::mapped_type mapped_type;
+	typedef typename cntnr::const_mapped_reference const_mapped_reference;
+
+	template<typename Gen>
+	static key_type
+        generate_key(Gen& r_gen, size_t max)
+	{ return basic_type(r_gen, max); }
+
+	template<typename Gen>
+	static value_type
+        generate_value(Gen& r_gen, size_t max)
+	{ return generate_value(r_gen, max, value_type()); }
+
+	static const_key_reference
+        extract_key(const_reference r_val)
+	{ return extract_key_imp(r_val); }
+
+      private:
+	typedef typename cntnr::allocator_type::template rebind<basic_type>::other
+	basic_type_rebind;
+	
+	typedef typename basic_type_rebind::const_reference basic_type_const_reference;
+
+	typedef typename cntnr::allocator_type::template rebind<std::pair<const basic_type, basic_type> >::other pair_type_rebind;
+	typedef typename pair_type_rebind::const_reference pair_type_const_reference;
+
+	template<typename Gen>
+	static value_type
+        generate_value(Gen& r_gen, size_t max, __gnu_pbds::null_mapped_type)
+	{ return basic_type(r_gen, max); }
+
+	template<typename Gen>
+	static value_type
+        generate_value(Gen& r_gen, size_t max, basic_type)
+	{ return basic_type(r_gen, max); }
+
+	template<typename Gen>
+	static value_type
+        generate_value(Gen& gen, size_t max, 
+		       std::pair<const basic_type, basic_type>)
+	{ return std::make_pair(basic_type(gen, max), basic_type(gen, max)); }
+
+	static const_key_reference
+        extract_key_imp(basic_type_const_reference r_val)
+	{ return r_val; }
+
+	static const_key_reference
+        extract_key_imp(pair_type_const_reference r_val)
+	{ return r_val.first; }
+      };
+    } // namespace detail
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/libstdc++-v3/testsuite/util/regression/trait/erase_if_fn.hpp b/libstdc++-v3/testsuite/util/regression/trait/erase_if_fn.hpp
new file mode 100644
index 000000000..9903dfeb3
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/regression/trait/erase_if_fn.hpp
@@ -0,0 +1,85 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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_if_fn.hpp
+ * Contains traits for a random regression test
+ *    for a specific container type.
+ */
+
+#ifndef PB_DS_REGRESSION_TEST_ERASE_IF_FN_HPP
+#define PB_DS_REGRESSION_TEST_ERASE_IF_FN_HPP
+
+#include <functional>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      template<typename T>
+      struct regression_test_erase_if_fn 
+      : public std::unary_function<T, bool>
+      {
+      private:
+	typedef const T&  const_reference;
+
+      public:
+	bool
+        operator()(const_reference r_t) const
+	{
+	  return (r_t.length() == 0 ||
+		  static_cast<size_t>(*((r_t).begin())) % 2 == 1);
+	}
+      };
+
+      template<typename Hd, class Tl>
+      struct regression_test_erase_if_fn<std::pair<Hd, Tl> > 
+      : public std::unary_function<std::pair<Hd, Tl>, bool>
+      {
+      private:
+	typedef const std::pair<Hd, Tl>&  const_reference;
+	typedef regression_test_erase_if_fn<Hd> hd_erase_if_fn;
+	typedef regression_test_erase_if_fn<Tl> tl_erase_if_fn;
+
+      public:
+	bool
+        operator()(const_reference r_t) const
+	{
+	  return (hd_erase_if_fn()(r_t.first) && tl_erase_if_fn()(r_t.second));
+	}
+      };
+    } // namespace detail
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/libstdc++-v3/testsuite/util/regression/trait/priority_queue/trait.hpp b/libstdc++-v3/testsuite/util/regression/trait/priority_queue/trait.hpp
new file mode 100644
index 000000000..f55dbbc99
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/regression/trait/priority_queue/trait.hpp
@@ -0,0 +1,82 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 trait.hpp
+ * Contains traits for a random regression test
+ *    for a specific container type.
+ */
+
+#ifndef PB_DS_REGRESSION_TEST_TRAIT_HPP
+#define PB_DS_REGRESSION_TEST_TRAIT_HPP
+
+#include <regression/trait/erase_if_fn.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      template<typename Cntnr>
+      struct regression_test_traits
+      {
+	typedef typename Cntnr::value_type value_type;
+	typedef typename Cntnr::const_reference const_reference;
+	typedef __gnu_pbds::test::native_priority_queue<std::string, true> native_type;
+	typedef typename native_type::value_type native_value_type;
+
+	template<typename T>
+	struct erase_if_fn : public regression_test_erase_if_fn<T>
+	{ };
+
+	template<typename Gen>
+	static value_type
+        generate_value(Gen& r_gen, size_t max)
+	{ return basic_type(r_gen, max); }
+
+	static native_value_type
+        native_value(const_reference r_val)
+	{ return native_value_type(r_val); }
+
+	static bool
+        cmp(const_reference r_val, const native_value_type& r_native_val)
+	{ return val_to_string(r_val) == r_native_val; }
+
+	static std::string
+        val_to_string(const_reference r_val)
+	{ return std::string(r_val); }
+      };
+    } // namespace detail
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
diff --git a/libstdc++-v3/testsuite/util/replacement_memory_operators.h b/libstdc++-v3/testsuite/util/replacement_memory_operators.h
new file mode 100644
index 000000000..b7d3a3b10
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/replacement_memory_operators.h
@@ -0,0 +1,113 @@
+//
+// Copyright (C) 2007, 2009, 2010 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <exception>
+#include <stdexcept>
+#include <cstdlib>
+#include <cstdio>
+
+namespace __gnu_test
+{
+  struct counter_error : public std::exception { };
+
+  struct counter
+  {
+    std::size_t _M_count;
+    bool	_M_throw;
+
+    counter() : _M_count(0), _M_throw(true) { }
+    
+    ~counter()
+    {
+      if (_M_throw && _M_count != 0)
+	throw counter_error();
+    }
+
+    static void
+    increment() { get()._M_count++; }
+
+    static void
+    decrement() { get()._M_count--; }
+
+    static counter&
+    get() 
+    {
+      static counter g;
+      return g;
+    }
+  
+    static std::size_t
+    count() { return get()._M_count; }
+
+    static void
+    exceptions(bool __b) { get()._M_throw = __b; }
+  };
+
+  template<typename Alloc, bool uses_global_new>
+    bool 
+    check_new(Alloc a = Alloc())
+    {
+      __gnu_test::counter::exceptions(false);
+      a.allocate(10);
+      const bool __b((__gnu_test::counter::count() > 0) == uses_global_new);
+      if (!__b)
+	throw std::logic_error("counter not incremented");
+      return __b;
+    }
+
+  template<typename Alloc, bool uses_global_delete>
+    bool 
+    check_delete(Alloc a = Alloc())
+    {
+      __gnu_test::counter::exceptions(false);
+      typename Alloc::pointer p = a.allocate(10);
+      const std::size_t count1 = __gnu_test::counter::count();
+      a.deallocate(p, 10);
+      const std::size_t count2 = __gnu_test::counter::count();
+      const bool __b((count2 < count1) == uses_global_delete);
+      if (!__b)
+	throw std::logic_error("counter not decremented");
+      return __b;
+    }
+} // namespace __gnu_test
+
+void* operator new(std::size_t size) throw(std::bad_alloc)
+{
+  std::printf("operator new is called \n");
+  void* p = std::malloc(size);
+  if (!p)
+    throw std::bad_alloc();
+  __gnu_test::counter::increment();
+  return p;
+}
+ 
+void operator delete(void* p) throw()
+{
+  std::printf("operator delete is called \n");
+  if (p)
+    {
+      std::free(p);
+      __gnu_test::counter::decrement();
+
+      std::size_t count = __gnu_test::counter::count(); 
+      if (count == 0)
+	std::printf("All memory released \n");
+      else
+	std::printf("%lu allocations to be released \n", (unsigned long)count);
+    }
+}
diff --git a/libstdc++-v3/testsuite/util/statistic/result_recorder.hpp b/libstdc++-v3/testsuite/util/statistic/result_recorder.hpp
new file mode 100644
index 000000000..fd638e22e
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/statistic/result_recorder.hpp
@@ -0,0 +1,98 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 result_recorder.hpp
+ * Contains a class for recording results
+ */
+
+#ifndef PB_DS_RES_RECORDER_HPP
+#define PB_DS_RES_RECORDER_HPP
+
+#include <statistic/sample_mean.hpp>
+#include <statistic/sample_variance.hpp>
+#include <statistic/sample_mean_confidence_checker.hpp>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      /*
+       * Records results until the probability that the sample mean is 10% away
+       * from the true mean is ~ 0.05.
+       */
+      template<typename Value_Type>
+      class result_recorder
+      {
+      public:
+	typedef Value_Type value_type;
+
+	result_recorder()
+        : m_sample_mean(value_type()), m_sample_var(value_type())
+	{ }
+
+	bool
+        add_result(value_type res);
+
+	inline value_type
+        get_sample_mean() const
+	{ return m_sample_mean; }
+
+      private:
+	typedef std::list<value_type> list_type;
+
+	list_type m_l;
+	value_type m_sample_mean;
+	value_type m_sample_var;
+      };
+
+
+      template<typename Value_Type>
+      bool
+      result_recorder<Value_Type>::
+      add_result(value_type res)
+      {
+	m_l.push_back(res);
+	m_sample_mean = sample_mean(m_l.begin(), m_l.end());
+	m_sample_var = sample_variance(m_l.begin(), m_l.end(), m_sample_mean);
+
+	size_t dist = std::distance(m_l.begin(), m_l.end());
+	return sample_mean_confidence_checker(m_sample_mean, m_sample_var,
+					      dist, 0.1);
+      }
+    } // namespace detail
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
+
diff --git a/libstdc++-v3/testsuite/util/statistic/sample_mean.hpp b/libstdc++-v3/testsuite/util/statistic/sample_mean.hpp
new file mode 100644
index 000000000..8dfdab8e2
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/statistic/sample_mean.hpp
@@ -0,0 +1,69 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 sample_mean.hpp
+ * Contains a function for calculating a sample mean
+ */
+
+#ifndef PB_DS_SAMPLE_MEAN_HPP
+#define PB_DS_SAMPLE_MEAN_HPP
+
+#include <list>
+#include <numeric>
+#include <math.h>
+#include <iterator>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+#define PB_DS_VTYPE typename std::iterator_traits<It>::value_type
+
+      template<typename It>
+      PB_DS_VTYPE
+      sample_mean(It b, It e)
+      {
+	const PB_DS_VTYPE total = std::accumulate(b, e, PB_DS_VTYPE(0));
+	const size_t num = std::distance(b, e);
+	return total / num;
+      }
+
+#undef PB_DS_VTYPE
+
+    } // namespace detail
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
+
diff --git a/libstdc++-v3/testsuite/util/statistic/sample_mean_confidence_checker.hpp b/libstdc++-v3/testsuite/util/statistic/sample_mean_confidence_checker.hpp
new file mode 100644
index 000000000..d63f34bcb
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/statistic/sample_mean_confidence_checker.hpp
@@ -0,0 +1,84 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 sample_mean_confidence_checker.hpp
+ * Contains a function for checking the confidence of a sample mean
+ */
+
+#ifndef PB_DS_SAMPLE_MEAN_CONFIDENCE_CHECKER_HPP
+#define PB_DS_SAMPLE_MEAN_CONFIDENCE_CHECKER_HPP
+
+#include <list>
+#include <numeric>
+#include <math.h>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+      /*
+       * Checks that a sample mean sm is in the relative interval
+       * relative_interval of a true mean (assuming i.i.d. samples),
+       * given a sample variance sv taken over num_samples samples,
+       * with confidence ~ 0.95.
+       *
+       * See "Probability, Random Variables, and Stochastic Processes"
+       * (Third edition) Athanasios Papoulis, Chapter 9.
+       */
+      template<typename Value_Type>
+      bool
+      sample_mean_confidence_checker(Value_Type sm, Value_Type sv, 
+				     std::size_t num_samples, 
+				     double relative_interval)
+      {
+	enum
+	  {
+	    // Ensures that the student-t distribution is approximately normal.
+	    min_num_samples = 30
+	  };
+
+	if (num_samples < min_num_samples)
+	  return (false);
+
+	// This is z_u (normal-dist percentile) for u = 0.975.
+	const Value_Type z = 1.976;
+
+	return (sv / ::sqrt(double(num_samples)) <= relative_interval * sm / z);
+      }
+    } // namespace detail
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
+
diff --git a/libstdc++-v3/testsuite/util/statistic/sample_variance.hpp b/libstdc++-v3/testsuite/util/statistic/sample_variance.hpp
new file mode 100644
index 000000000..ed61d0b05
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/statistic/sample_variance.hpp
@@ -0,0 +1,81 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 sample_variance.hpp
+ * Contains a function for calculating a sample variance
+ */
+
+#ifndef PB_DS_SAMPLE_VAR_HPP
+#define PB_DS_SAMPLE_VAR_HPP
+
+#include <list>
+#include <numeric>
+#include <math.h>
+#include <iterator>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    namespace detail
+    {
+#define PB_DS_VTYPE typename std::iterator_traits<It>::value_type
+
+      template<typename It>
+      PB_DS_VTYPE
+      sample_variance(It b, It e, PB_DS_VTYPE sm)
+      {
+	PB_DS_VTYPE ss = 0;
+	size_t num_res = 0;
+
+	while (b != e)
+	  {
+	    const PB_DS_VTYPE d =* b - sm;
+	    ss += d*  d;
+	    ++num_res;
+	    ++b;
+	  }
+
+	if (num_res == 1)
+	  return 0;
+
+	return ::sqrt(ss / (num_res - 1));
+      }
+
+#undef PB_DS_VTYPE
+
+    } // namespace detail
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif 
+
diff --git a/libstdc++-v3/testsuite/util/testsuite_abi.cc b/libstdc++-v3/testsuite/util/testsuite_abi.cc
new file mode 100644
index 000000000..ea100b681
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_abi.cc
@@ -0,0 +1,563 @@
+// -*- C++ -*-
+
+// Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
+// Free Software Foundation, Inc.
+
+// 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// Benjamin Kosnik  <bkoz@redhat.com>
+
+#include "testsuite_abi.h"
+#include <cstdlib>
+#include <sstream>
+#include <fstream>
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+void 
+symbol::init(string& data)
+{
+  const char delim = ':';
+  const char version_delim = '@';
+  const string::size_type npos = string::npos;
+  string::size_type n = 0;
+
+  // Set the type.
+  if (data.find("FUNC") == 0)
+    type = symbol::function;
+  else if (data.find("OBJECT") == 0)
+    type = symbol::object;
+  else if (data.find("TLS") == 0)
+    type = symbol::tls;
+
+  n = data.find_first_of(delim);
+  if (n != npos)
+    data.erase(data.begin(), data.begin() + n + 1);
+
+  // Iff object or TLS, get size info.
+  if (type == symbol::object || type == symbol::tls)
+    {
+      n = data.find_first_of(delim);
+      if (n != npos)
+	{
+	  string objectsize(data.begin(), data.begin() + n);
+	  istringstream iss(objectsize);
+	  int x;
+	  iss >> x;
+	  if (!iss.fail())
+	    size = x;
+	  data.erase(data.begin(), data.begin() + n + 1);
+	}
+    }
+
+  // Set the name and raw_name.
+  raw_name = string(data.begin(), data.end());
+  n = data.find_first_of(version_delim);
+  if (n != npos)
+    {
+      // Found version string.
+      name = string(data.begin(), data.begin() + n);
+      n = data.find_last_of(version_delim);
+      data.erase(data.begin(), data.begin() + n + 1);
+
+      // Set version name.
+      version_name = data;
+    }
+  else
+    {
+      // No versioning info.
+      name = string(data.begin(), data.end());
+      version_status = symbol::none;
+    }
+
+  // Set the demangled name.
+  demangled_name = demangle(name);
+}
+
+void
+symbol::print() const
+{
+  const char tab = '\t';
+  cout << name << endl;
+
+  if (demangled_name != name)
+    cout << demangled_name << endl;
+
+  string vers;
+  switch (version_status)
+    {
+    case none:
+      vers = "none";
+      break;
+    case compatible:
+      vers = "compatible";
+      break;
+    case incompatible:
+      vers = "incompatible";
+      break;
+     case unversioned:
+      vers = "unversioned";
+      break;
+   default:
+      vers = "<default>";
+    }
+  cout << "version status: " << vers << endl;
+
+  if (version_name.size() 
+      && (version_status == compatible || version_status == incompatible))
+    cout << version_name << endl;  
+
+  string type_string;
+  switch (type)
+    {
+    case function:
+      type_string = "function";
+      break;
+    case object:
+      type_string = "object";
+      break;
+    case tls:
+      type_string = "tls";
+      break;
+    case uncategorized:
+      type_string = "uncategorized";
+      break;
+    default:
+      type_string = "<default>";
+    }
+  cout << "type: " << type_string << endl;
+  
+  if (type == object || type == tls)
+    cout << "type size: " << size << endl;
+
+  string status_string;
+  switch (status)
+    {
+    case added:
+      status_string = "added";
+      break;
+    case subtracted:
+      status_string = "subtracted";
+      break;
+    case undesignated:
+      status_string = "undesignated";
+      break;
+    default:
+      status_string = "<default>";
+    }
+  cout << "status: " << status_string << endl;
+
+  cout << endl;
+}
+
+
+bool
+check_version(symbol& test, bool added)
+{
+  // Construct list of compatible versions.
+  typedef std::vector<std::string> compat_list;
+  static compat_list known_versions;
+  if (known_versions.empty())
+    {
+      // NB: First version here must be the default version for this
+      // version of DT_SONAME.
+      known_versions.push_back("GLIBCXX_3.4");
+      known_versions.push_back("GLIBCXX_3.4.1");
+      known_versions.push_back("GLIBCXX_3.4.2");
+      known_versions.push_back("GLIBCXX_3.4.3");
+      known_versions.push_back("GLIBCXX_3.4.4"); 
+      known_versions.push_back("GLIBCXX_3.4.5");
+      known_versions.push_back("GLIBCXX_3.4.6");
+      known_versions.push_back("GLIBCXX_3.4.7");
+      known_versions.push_back("GLIBCXX_3.4.8");
+      known_versions.push_back("GLIBCXX_3.4.9");
+      known_versions.push_back("GLIBCXX_3.4.10");
+      known_versions.push_back("GLIBCXX_3.4.11");
+      known_versions.push_back("GLIBCXX_3.4.12");
+      known_versions.push_back("GLIBCXX_3.4.13");
+      known_versions.push_back("GLIBCXX_3.4.14");
+      known_versions.push_back("GLIBCXX_3.4.15");
+      known_versions.push_back("GLIBCXX_3.4.16");
+      known_versions.push_back("GLIBCXX_LDBL_3.4");
+      known_versions.push_back("GLIBCXX_LDBL_3.4.7");
+      known_versions.push_back("GLIBCXX_LDBL_3.4.10");
+      known_versions.push_back("CXXABI_1.3");
+      known_versions.push_back("CXXABI_1.3.1");
+      known_versions.push_back("CXXABI_1.3.2");
+      known_versions.push_back("CXXABI_1.3.3");
+      known_versions.push_back("CXXABI_1.3.4");
+      known_versions.push_back("CXXABI_1.3.5");
+      known_versions.push_back("CXXABI_LDBL_1.3");
+    }
+  compat_list::iterator begin = known_versions.begin();
+  compat_list::iterator end = known_versions.end();
+
+  // Check for compatible version.
+  if (test.version_name.size())
+    {
+      compat_list::iterator it1 = find(begin, end, test.version_name);
+      compat_list::iterator it2 = find(begin, end, test.name);
+      if (it1 != end)
+	test.version_status = symbol::compatible;
+      else
+	test.version_status = symbol::incompatible;
+      
+      // Check that added symbols aren't added in the base versions.
+      if (added
+	  && (test.version_name == known_versions[0]
+	      || test.version_name == "CXXABI_1.3"
+	      || test.version_name == "GLIBCXX_LDBL_3.4"
+	      || test.version_name == "CXXABI_LDBL_1.3"))
+	test.version_status = symbol::incompatible;
+
+      // Check that long double compatibility symbols demangled as
+      // __float128 are put into some _LDBL_ version name.
+      if (added && test.demangled_name.find("__float128") != std::string::npos)
+	{
+	  // Has to be in _LDBL_ version name.
+	  if (test.version_name.find("_LDBL_") == std::string::npos)
+	    test.version_status = symbol::incompatible;
+	}
+
+      // Check for weak label.
+      if (it1 == end && it2 == end)
+	test.version_status = symbol::incompatible;
+      
+      // Check that 
+      // GLIBCXX_3.4
+      // GLIBCXX_3.4.5
+      // version as compatible
+      // XXX
+    }
+  else
+    {
+      if (added)
+	{
+	  // New version labels are ok. The rest are not.
+	  compat_list::iterator it2 = find(begin, end, test.name);
+	  if (it2 != end)
+	    test.version_status = symbol::compatible;
+	  else
+	    test.version_status = symbol::incompatible;
+	}
+    }
+  return test.version_status == symbol::compatible;
+}
+
+bool 
+check_compatible(symbol& lhs, symbol& rhs, bool verbose)
+{
+  bool ret = true;
+  const char tab = '\t';
+
+  // Check to see if symbol_objects are compatible.
+  if (lhs.type != rhs.type)
+    {
+      ret = false;
+      if (verbose)
+	cout << tab << "incompatible types" << endl;
+    }
+  
+  if (lhs.name != rhs.name)
+    {
+      ret = false;
+      if (verbose)
+	cout << tab << "incompatible names" << endl;
+    }
+
+  if (lhs.size != rhs.size)
+    {
+      ret = false;
+      if (verbose)
+	{
+	  cout << tab << "incompatible sizes" << endl;
+	  cout << tab << lhs.size << endl;
+	  cout << tab << rhs.size << endl;
+	}
+    }
+
+  if (lhs.version_name != rhs.version_name 
+      && !check_version(lhs) && !check_version(rhs))
+    {
+      ret = false;
+      if (verbose)
+	{
+	  cout << tab << "incompatible versions" << endl;
+	  cout << tab << lhs.version_name << endl;
+	  cout << tab << rhs.version_name << endl;
+	}
+    }
+
+  if (verbose)
+    cout << endl;
+
+  return ret;
+}
+
+
+inline bool
+has_symbol(const string& name, const symbols& s) throw()
+{ return s.find(name) != s.end(); }
+
+const symbol&
+get_symbol(const string& name, const symbols& s)
+{
+  symbols::const_iterator i = s.find(name);
+  if (i != s.end())
+    {
+      return i->second;
+    }
+  else
+    {
+      ostringstream os;
+      os << "get_symbol failed for symbol " << name;
+      __throw_logic_error(os.str().c_str());
+    }
+}
+
+void 
+examine_symbol(const char* name, const char* file)
+{
+  try
+    {
+      symbols s = create_symbols(file);
+      const symbol& sym = get_symbol(name, s);
+      sym.print();
+    }
+  catch(...)
+    { __throw_exception_again; }
+}
+
+int
+compare_symbols(const char* baseline_file, const char* test_file, 
+		bool verbose)
+{
+  // Input both lists of symbols into container.
+  symbols baseline = create_symbols(baseline_file);
+  symbols test = create_symbols(test_file);
+
+  //  Sanity check results.
+  if (!baseline.size() || !test.size())
+    {
+      cerr << "Problems parsing the list of exported symbols." << endl;
+      exit(2);
+    }
+
+  // Check to see if any long double compatibility symbols are produced.
+  bool ld_version_found(false);
+  symbols::iterator li(test.begin());
+  while (!ld_version_found && li != test.end())
+    {
+      if (li->second.version_name.find("_LDBL_") != std::string::npos)
+	ld_version_found = true;
+      ++li;
+    }
+
+  // Sort out names.
+  // Assuming all baseline names and test names are both unique w/ no
+  // duplicates.
+  //
+  // The names added to missing_names are baseline names not found in
+  // test names 
+  // -> symbols that have been deleted.
+  //
+  // The names added to added_names are test names not in
+  // baseline names
+  // -> symbols that have been added.
+  typedef std::vector<std::string> symbol_names;
+  symbol_names shared_names;
+  symbol_names missing_names;
+  symbol_names added_names;
+  for (li = test.begin(); li != test.end(); ++li)
+    added_names.push_back(li->first);
+
+  for (symbols::iterator i = baseline.begin(); i != baseline.end(); ++i)
+    {
+      string name(i->first);
+      symbol_names::iterator end = added_names.end();
+      symbol_names::iterator it = find(added_names.begin(), end, name);
+      if (it != end)
+	{
+	  // Found.
+	  shared_names.push_back(name);
+	  added_names.erase(it);
+	}
+       else
+	{
+	  // Iff no test long double compatibility symbols at all and the symbol
+	  // missing is a baseline long double compatibility symbol, skip.
+	  string version_name(i->second.version_name);
+	  bool base_ld(version_name.find("_LDBL_") != std::string::npos);
+	  if (!base_ld || base_ld && ld_version_found)
+	    missing_names.push_back(name);
+	}
+    }
+
+  // Fill out list of incompatible symbols.
+  typedef pair<symbol, symbol> symbol_pair;
+  vector<symbol_pair> incompatible;
+
+  // Check missing names for compatibility.
+  for (size_t j = 0; j < missing_names.size(); ++j)
+    {
+      symbol& sbase = baseline[missing_names[j]];
+      sbase.status = symbol::subtracted;
+      incompatible.push_back(symbol_pair(sbase, sbase));
+    }
+
+  // Check shared names for compatibility.
+  const symbol_names::size_type shared_size = shared_names.size();
+  for (size_t k = 0; k < shared_size; ++k)
+    {
+      symbol& sbase = baseline[shared_names[k]];
+      symbol& stest = test[shared_names[k]];
+      stest.status = symbol::existing;
+      if (!check_compatible(sbase, stest))
+	incompatible.push_back(symbol_pair(sbase, stest));
+    }
+
+  // Check added names for compatibility.
+  const symbol_names::size_type added_size = added_names.size();
+  for (size_t l = 0; l < added_size; ++l)
+    {
+      symbol& stest = test[added_names[l]];
+      stest.status = symbol::added;
+      if (!check_version(stest, true))
+	incompatible.push_back(symbol_pair(stest, stest));
+    }
+
+  // Report results.
+  if (verbose && added_names.size())
+    {
+      cout << endl << added_names.size() << " added symbols " << endl;
+      for (size_t j = 0; j < added_names.size() ; ++j)
+	{
+	  cout << j << endl;
+	  test[added_names[j]].print();
+	}
+    }
+  
+  if (verbose && missing_names.size())
+    {
+      cout << endl << missing_names.size() << " missing symbols " << endl;
+      for (size_t j = 0; j < missing_names.size() ; ++j)
+	{
+	  cout << j << endl;
+	  baseline[missing_names[j]].print();
+	}
+    }
+  
+  if (verbose && incompatible.size())
+    {
+      cout << endl << incompatible.size() << " incompatible symbols " << endl;
+      for (size_t j = 0; j < incompatible.size() ; ++j)
+	{
+	  // First, print index.
+	  cout << j << endl;
+
+	  // Second, report name.
+	  symbol& sbase = incompatible[j].first;
+	  symbol& stest = incompatible[j].second;
+	  stest.print();
+	  
+	  // Second, report reason or reasons incompatible.
+	  check_compatible(sbase, stest, true);
+	}
+    }
+  
+  cout << "\n\t\t=== libstdc++-v3 check-abi Summary ===" << endl;
+  cout << endl;
+  cout << "# of added symbols:\t\t " << added_names.size() << endl;
+  cout << "# of missing symbols:\t\t " << missing_names.size() << endl;
+  cout << "# of incompatible symbols:\t " << incompatible.size() << endl;
+  cout << endl;
+  cout << "using: " << baseline_file << endl;
+
+  return !(missing_names.size() || incompatible.size());
+}
+
+
+symbols
+create_symbols(const char* file)
+{
+  symbols s;
+  ifstream ifs(file);
+  if (ifs.is_open())
+    {
+      // Organize file data into an associated container (symbols) of symbol
+      // objects mapped to mangled names without versioning
+      // information.
+      const string empty;
+      string line = empty;
+      while (getline(ifs, line).good())
+	{
+	  symbol tmp;
+	  tmp.init(line);
+	  s[tmp.name] = tmp;
+	  line = empty;
+	}
+    }
+  else
+    {
+      ostringstream os;
+      os << "create_symbols failed for file " << file;
+      __throw_runtime_error(os.str().c_str());
+    }
+  return s;
+}
+
+
+const char*
+demangle(const std::string& mangled)
+{
+  const char* name;
+  if (mangled[0] != '_' || mangled[1] != 'Z')
+    {
+      // This is not a mangled symbol, thus has "C" linkage.
+      name = mangled.c_str();
+    }
+  else
+    {
+      // Use __cxa_demangle to demangle.
+      int status = 0;
+      name = abi::__cxa_demangle(mangled.c_str(), 0, 0, &status);
+      if (!name)
+	{
+	  switch (status)
+	    {
+	    case 0:
+	      name = "error code = 0: success";
+	      break;
+	    case -1:
+	      name = "error code = -1: memory allocation failure";
+	      break;
+	    case -2:
+	      name = "error code = -2: invalid mangled name";
+	      break;
+	    case -3:
+	      name = "error code = -3: invalid arguments";
+	      break;
+	    default:
+	      name = "error code unknown - who knows what happened";
+	    }
+	}
+    }
+  return name;
+}
+
diff --git a/libstdc++-v3/testsuite/util/testsuite_abi.h b/libstdc++-v3/testsuite/util/testsuite_abi.h
new file mode 100644
index 000000000..bff39903e
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_abi.h
@@ -0,0 +1,99 @@
+// -*- C++ -*-
+
+// Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010
+// Free Software Foundation, Inc.
+
+// 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// Benjamin Kosnik  <bkoz@redhat.com>
+
+#include <string>
+#include <stdexcept>
+#include <vector>
+#include <locale>
+#include <tr1/unordered_map>
+#include <cxxabi.h>
+
+// Encapsulates symbol characteristics.
+struct symbol
+{
+  enum category { function, object, tls, uncategorized };
+  enum designation { existing, added, subtracted, undesignated };
+  enum version { none, compatible, incompatible, unversioned };
+  enum compatibility 
+    { 
+      compat_type = 1, 
+      compat_name = 2, 
+      compat_size = 4, 
+      compat_version = 8 
+    };
+
+  category 	type;
+  std::string 	name;
+  std::string 	raw_name; // Name with versioning info still attached.
+  std::string 	demangled_name;
+  int 		size;
+  std::string 	version_name;
+  version	version_status;
+  designation	status;
+
+  symbol() 
+  : type(uncategorized), size(0), version_status(unversioned), 
+    status(undesignated) { }
+
+  symbol(const symbol& other) 
+  : type(other.type), name(other.name), demangled_name(other.demangled_name), 
+    size(other.size), version_name(other.version_name), 
+    version_status(other.version_status), status(other.status) { }
+
+  void
+  print() const;
+
+  void
+  init(std::string& data);
+};
+
+// Map type between symbol names and full symbol info.
+typedef std::tr1::unordered_map<std::string, symbol> 	symbols;
+
+
+// Check.
+bool
+check_version(symbol& test, bool added = false);
+
+bool 
+check_compatible(symbol& lhs, symbol& rhs, bool verbose = false);
+
+
+// Examine.
+bool
+has_symbol(const std::string& mangled, const symbols& list) throw();
+
+const symbol&
+get_symbol(const std::string& mangled, const symbols& list);
+
+extern "C" void
+examine_symbol(const char* name, const char* file);
+
+extern "C" int
+compare_symbols(const char* baseline_file, const char* test_file, bool verb);
+
+
+// Util.
+symbols
+create_symbols(const char* file);
+
+const char*
+demangle(const std::string& mangled);
diff --git a/libstdc++-v3/testsuite/util/testsuite_abi_check.cc b/libstdc++-v3/testsuite/util/testsuite_abi_check.cc
new file mode 100644
index 000000000..d4fea3ae6
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_abi_check.cc
@@ -0,0 +1,86 @@
+// -*- C++ -*-
+
+// Copyright (C) 2004, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+
+// 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// Benjamin Kosnik  <bkoz@redhat.com>
+// Blame subsequent hacks on Loren J. Rittle <ljrittle@acm.org>, Phil
+// Edwards <pme@gcc.gnu.org>, and a cast of dozens at libstdc++@gcc.gnu.org.
+ 
+#include "testsuite_abi.h"
+#include <iostream>
+#include <cstdlib>
+#include <unistd.h>    // for access(2)
+
+int
+main(int argc, char** argv)
+{
+  using namespace std;
+
+  // Get arguments.  (Heading towards getopt_long, I can feel it.)
+  string argv1 = argc > 1 ? argv[1] : "";
+  if (argv1 == "--help" || argc < 4)
+    {
+      cerr << "usage: abi_check --check         current baseline\n"
+              "                 --check-verbose current baseline\n"
+              "                 --examine       symbol current\n"
+              "                 --help\n"
+	      "\n"
+              "All arguments are string literals.\n"
+	      "CURRENT is a file generated byextract_symvers.\n"
+              "BASELINE is a file from config/abi.\n"
+              "SYMBOL is a mangled name.\n"
+	   << endl;
+      exit(1);
+    }
+  
+  if (argv1.find("--check") != string::npos)
+    {
+      bool verbose = false;
+      if (argv1 == "--check-verbose")
+	verbose = true;
+      
+      // Quick sanity/setup check for arguments.
+      const char* test_file = argv[2];
+      const char* baseline_file = argv[3];
+      if (access(test_file, R_OK) != 0)
+	{
+	  cerr << "Cannot read symbols file " << test_file
+	       << ", did you forget to build first?" << endl;
+	  exit(1);
+	}
+      if (access(baseline_file, R_OK) != 0)
+	{
+	  cerr << "Cannot read baseline file " << baseline_file << endl;
+	exit(1);
+	}
+      if (!compare_symbols(baseline_file, test_file, verbose))
+	exit (1);
+    }
+  
+  if (argv1 == "--examine")
+    {
+      const char* file = argv[3];
+      if (access(file, R_OK) != 0)
+	{
+	  cerr << "Cannot read symbol file " << file << endl;
+	  exit(1);
+	}
+      examine_symbol(argv[2], file);
+    }
+  return 0;
+}
diff --git a/libstdc++-v3/testsuite/util/testsuite_allocator.cc b/libstdc++-v3/testsuite/util/testsuite_allocator.cc
new file mode 100644
index 000000000..a5fbc77d2
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_allocator.cc
@@ -0,0 +1,56 @@
+// -*- C++ -*-
+// Testing allocator for the C++ library testsuite.
+//
+// Copyright (C) 2002, 2003, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+//
+
+#include <iostream>
+#include <testsuite_allocator.h>
+
+namespace __gnu_test
+{
+  typedef tracker_allocator_counter counter_type;
+  
+  counter_type::size_type 
+  counter_type::allocationCount_ = 0;
+  
+  counter_type::size_type 
+  counter_type::deallocationCount_ = 0;
+
+  int counter_type::constructCount_ = 0;
+  int counter_type::destructCount_ = 0;
+
+  bool
+  check_construct_destroy(const char* tag, int expected_c, int expected_d)
+  {
+    bool ret = true;
+    if (counter_type::get_construct_count() != expected_c 
+	|| counter_type::get_destruct_count() != expected_d)
+      {
+	std::cerr << tag << ": "
+		  << " construct = " << counter_type::get_construct_count()
+		  << " (should be " << expected_c << "),"
+		  << " destroy = " << counter_type::get_destruct_count()
+		  << " (should be " << expected_d << ")"
+		  << std::endl;
+	ret = false;
+      }
+    return ret;
+  }
+} // namespace __cxx_test
+
diff --git a/libstdc++-v3/testsuite/util/testsuite_allocator.h b/libstdc++-v3/testsuite/util/testsuite_allocator.h
new file mode 100644
index 000000000..a534d8584
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_allocator.h
@@ -0,0 +1,354 @@
+// -*- C++ -*-
+// Testing allocator for the C++ library testsuite.
+//
+// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+// 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+//
+
+// This file provides an test instrumentation allocator that can be
+// used to verify allocation functionality of standard library
+// containers.  2002.11.25 smw
+
+#ifndef _GLIBCXX_TESTSUITE_ALLOCATOR_H
+#define _GLIBCXX_TESTSUITE_ALLOCATOR_H
+
+#include <tr1/unordered_map>
+#include <cassert>
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+#include <bits/move.h>
+#endif
+
+namespace __gnu_test
+{
+  class tracker_allocator_counter
+  {
+  public:
+    typedef std::size_t    size_type; 
+    
+    static void*
+    allocate(size_type blocksize)
+    {
+      allocationCount_ += blocksize;
+      return ::operator new(blocksize);
+    }
+    
+    static void
+    construct() { constructCount_++; }
+
+    static void
+    destroy() { destructCount_++; }
+
+    static void
+    deallocate(void* p, size_type blocksize)
+    {
+      ::operator delete(p);
+      deallocationCount_ += blocksize;
+    }
+    
+    static size_type
+    get_allocation_count() { return allocationCount_; }
+    
+    static size_type
+    get_deallocation_count() { return deallocationCount_; }
+    
+    static int
+    get_construct_count() { return constructCount_; }
+
+    static int
+    get_destruct_count() { return destructCount_; }
+    
+    static void
+    reset()
+    {
+      allocationCount_ = 0;
+      deallocationCount_ = 0;
+      constructCount_ = 0;
+      destructCount_ = 0;
+    }
+
+ private:
+    static size_type  allocationCount_;
+    static size_type  deallocationCount_;
+    static int        constructCount_;
+    static int        destructCount_;
+  };
+
+  // A simple basic allocator that just forwards to the
+  // tracker_allocator_counter to fulfill memory requests.  This class
+  // is templated on the target object type, but tracker isn't.
+  template<class T>
+  class tracker_allocator
+  {
+  private:
+    typedef tracker_allocator_counter counter_type;
+
+  public:
+    typedef T              value_type;
+    typedef T*             pointer;
+    typedef const T*       const_pointer;
+    typedef T&             reference;
+    typedef const T&       const_reference;
+    typedef std::size_t    size_type; 
+    typedef std::ptrdiff_t difference_type; 
+    
+    template<class U> struct rebind { typedef tracker_allocator<U> other; };
+    
+    pointer
+    address(reference value) const
+    { return &value; }
+    
+    const_pointer
+    address(const_reference value) const
+    { return &value; }
+    
+    tracker_allocator() throw()
+    { }
+
+    tracker_allocator(const tracker_allocator&) throw()
+    { }
+
+    template<class U>
+      tracker_allocator(const tracker_allocator<U>&) throw()
+      { }
+
+    ~tracker_allocator() throw()
+    { }
+
+    size_type
+    max_size() const throw()
+    { return size_type(-1) / sizeof(T); }
+
+    pointer
+    allocate(size_type n, const void* = 0)
+    { return static_cast<pointer>(counter_type::allocate(n * sizeof(T))); }
+
+    void
+    construct(pointer p, const T& value)
+    {
+      ::new ((void *)p) T(value);
+      counter_type::construct();
+    }
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+      template<typename... Args>
+        void
+        construct(pointer p, Args&&... args) 
+	{
+	  ::new((void *)p) T(std::forward<Args>(args)...);
+	  counter_type::construct();
+	}
+#endif
+
+    void
+    destroy(pointer p)
+    {
+      p->~T();
+      counter_type::destroy();
+    }
+
+    void
+    deallocate(pointer p, size_type num)
+    { counter_type::deallocate(p, num * sizeof(T)); }
+  };
+
+  template<class T1, class T2>
+    bool
+    operator==(const tracker_allocator<T1>&, 
+	       const tracker_allocator<T2>&) throw()
+    { return true; }
+
+  template<class T1, class T2>
+    bool
+    operator!=(const tracker_allocator<T1>&, 
+	       const tracker_allocator<T2>&) throw()
+    { return false; }
+
+  bool
+  check_construct_destroy(const char* tag, int expected_c, int expected_d);
+
+  template<typename Alloc>
+    bool
+    check_deallocate_null()
+    {
+      // Let's not core here...
+      Alloc  a;
+      a.deallocate(0, 1);
+      a.deallocate(0, 10);
+      return true;
+    }
+
+  template<typename Alloc>
+    bool 
+    check_allocate_max_size()
+    {
+      Alloc a;
+      try
+	{
+	  a.allocate(a.max_size() + 1);
+	}
+      catch(std::bad_alloc&)
+	{
+	  return true;
+	}
+      catch(...)
+	{
+	  throw;
+	}
+      throw;
+    }
+
+
+  // A simple allocator which can be constructed endowed of a given
+  // "personality" (an integer), queried in operator== to simulate the
+  // behavior of realworld "unequal" allocators (i.e., not exploiting
+  // the provision in 20.1.5/4, first bullet).  A global unordered_map,
+  // filled at allocation time with (pointer, personality) pairs, is
+  // then consulted to enforce the requirements in Table 32 about
+  // deallocation vs allocator equality.  Note that this allocator is
+  // swappable, not assignable, consistently with Option 3 of DR 431
+  // (see N1599).
+  struct uneq_allocator_base
+  {
+    typedef std::tr1::unordered_map<void*, int>   map_type;
+
+    // Avoid static initialization troubles and/or bad interactions
+    // with tests linking testsuite_allocator.o and playing globally
+    // with operator new/delete.
+    static map_type&
+    get_map()
+    {
+      static map_type alloc_map;
+      return alloc_map;
+    }
+  };
+
+  template<typename Tp>
+    class uneq_allocator
+    : private uneq_allocator_base
+    {
+    public:
+      typedef std::size_t                         size_type;
+      typedef std::ptrdiff_t                      difference_type;
+      typedef Tp*                                 pointer;
+      typedef const Tp*                           const_pointer;
+      typedef Tp&                                 reference;
+      typedef const Tp&                           const_reference;
+      typedef Tp                                  value_type;
+      
+      template<typename Tp1>
+        struct rebind
+	{ typedef uneq_allocator<Tp1> other; };
+
+      uneq_allocator() throw()
+      : personality(0) { }
+
+      uneq_allocator(int person) throw()
+      : personality(person) { }
+      
+      template<typename Tp1>
+        uneq_allocator(const uneq_allocator<Tp1>& b) throw()
+	: personality(b.get_personality()) { }
+
+      int get_personality() const { return personality; }
+      
+      pointer
+      address(reference x) const { return &x; }
+    
+      const_pointer
+      address(const_reference x) const { return &x; }
+    
+      pointer
+      allocate(size_type n, const void* = 0)
+      { 
+	if (__builtin_expect(n > this->max_size(), false))
+	  std::__throw_bad_alloc();
+	
+	pointer p = static_cast<Tp*>(::operator new(n * sizeof(Tp)));
+	try
+	  {
+	    get_map().insert(map_type::value_type(reinterpret_cast<void*>(p),
+						  personality));
+	  }
+	catch(...)
+	  {
+	    ::operator delete(p);
+	    __throw_exception_again;
+	  }
+	return p;
+      }
+      
+      void
+      deallocate(pointer p, size_type)
+      {
+	assert( p );
+	
+	map_type::iterator it = get_map().find(reinterpret_cast<void*>(p));
+	assert( it != get_map().end() );
+
+	// Enforce requirements in Table 32 about deallocation vs
+	// allocator equality.
+	assert( it->second == personality );
+	
+	get_map().erase(it);
+	::operator delete(p);
+      }
+      
+      size_type
+      max_size() const throw() 
+      { return size_type(-1) / sizeof(Tp); }
+      
+      void 
+      construct(pointer p, const Tp& val) 
+      { ::new((void *)p) Tp(val); }
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+      template<typename... Args>
+        void
+        construct(pointer p, Args&&... args) 
+	{ ::new((void *)p) Tp(std::forward<Args>(args)...); }
+#endif
+
+      void 
+      destroy(pointer p) { p->~Tp(); }
+
+    private:
+      // Not assignable...
+      uneq_allocator&
+      operator=(const uneq_allocator&);
+
+      // ... yet swappable!
+      friend inline void
+      swap(uneq_allocator& a, uneq_allocator& b)
+      { std::swap(a.personality, b.personality); } 
+      
+      template<typename Tp1>
+        friend inline bool
+        operator==(const uneq_allocator& a, const uneq_allocator<Tp1>& b)
+        { return a.personality == b.personality; }
+
+      template<typename Tp1>
+        friend inline bool
+        operator!=(const uneq_allocator& a, const uneq_allocator<Tp1>& b)
+        { return !(a == b); }
+      
+      int personality;
+    };
+} // namespace __gnu_test
+
+#endif // _GLIBCXX_TESTSUITE_ALLOCATOR_H
diff --git a/libstdc++-v3/testsuite/util/testsuite_api.h b/libstdc++-v3/testsuite/util/testsuite_api.h
new file mode 100644
index 000000000..110079040
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_api.h
@@ -0,0 +1,197 @@
+// -*- C++ -*-
+// Exception testing utils for the C++ library testsuite. 
+//
+// Copyright (C) 2007, 2008, 2009, 2010 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+//
+
+#include <exception>
+#include <testsuite_hooks.h>
+
+#ifndef _TESTSUITE_API
+#define _TESTSUITE_API 1
+
+namespace __gnu_test
+{
+  // Checks for virtual public derivation in exception classes.
+  // See:
+  // http://www.boost.org/more/error_handling.html
+  struct bad_non_virtual : virtual public std::exception { };
+
+  template<typename Exception, bool DefaultCons>
+    struct diamond_derivation_base;
+
+  template<typename Exception>
+    struct diamond_derivation_base<Exception, true>
+    {
+      struct diamond_derivation_error
+      : bad_non_virtual, Exception
+      {
+	diamond_derivation_error()
+        : bad_non_virtual(), Exception() { }
+      };
+    };
+
+  template<typename Exception>
+    struct diamond_derivation_base<Exception, false>
+    {
+      struct diamond_derivation_error
+      : bad_non_virtual, Exception
+      {
+	diamond_derivation_error()
+	: bad_non_virtual(), Exception("construct diamond") { }
+      };
+    };
+  
+  template<typename Exception, bool DefaultCons>
+    struct diamond_derivation
+    : diamond_derivation_base<Exception, DefaultCons>
+    {
+      typedef diamond_derivation_base<Exception, DefaultCons> base_type;
+      typedef typename base_type::diamond_derivation_error error_type;
+
+      // NB: In the libstdc++-v3 testsuite, all the standard exception
+      // classes (+ a couple of extensions) are checked:  since they
+      // all derive *non* virtually from std::exception, the expected
+      // behavior is ambiguity.
+      static void test()
+      {
+	bool test __attribute__((unused)) = true;      
+	try
+	  { throw error_type(); }
+	catch (std::exception const&)
+	  { VERIFY( false ); }
+	catch (...) 
+	  { VERIFY( true ); }
+      }
+    };
+
+  // Testing type requirements for template arguments.
+  struct NonDefaultConstructible
+  {
+    NonDefaultConstructible(int) { }
+    NonDefaultConstructible(const NonDefaultConstructible&) { }
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+    // For std::iota.
+    NonDefaultConstructible&
+    operator++()
+    { return *this; }
+#endif
+  };
+ 
+  // See: 20.1.1 Template argument requirements.
+  inline bool
+  operator==(const NonDefaultConstructible&, const NonDefaultConstructible&)
+  { return false; }
+
+  inline bool
+  operator<(const NonDefaultConstructible&, const NonDefaultConstructible&)
+  { return false; }
+
+  // For 23 unordered_* requirements.
+  struct NonDefaultConstructible_hash
+  {
+    std::size_t
+    operator()(NonDefaultConstructible) const
+    { return 1; }
+  };
+
+  // For 26 numeric algorithms requirements, need addable,
+  // subtractable, multiplicable.
+  inline NonDefaultConstructible
+  operator+(const NonDefaultConstructible& lhs, 
+	    const NonDefaultConstructible& rhs)
+  { return NonDefaultConstructible(1); }
+
+  inline NonDefaultConstructible
+  operator-(const NonDefaultConstructible& lhs, 
+	    const NonDefaultConstructible& rhs)
+  { return NonDefaultConstructible(1); }
+
+  inline NonDefaultConstructible
+  operator*(const NonDefaultConstructible& lhs, 
+	    const NonDefaultConstructible& rhs)
+  { return NonDefaultConstructible(1); }
+
+  // Like unary_function, but takes no argument. (ie, void).
+  // Used for generator template parameter.
+  template<typename _Result>
+    struct void_function
+    {
+      typedef _Result result_type; 
+
+      result_type
+      operator()() const
+      { return result_type(); }
+    };
+
+  template<>
+    struct void_function<NonDefaultConstructible>
+    {
+      typedef NonDefaultConstructible result_type; 
+
+      result_type
+      operator()() const
+      { return result_type(2); }
+    };
+
+  // For std::addressof, etc.
+  struct OverloadedAddressAux { };
+  
+  struct OverloadedAddress
+  {
+    OverloadedAddressAux
+    operator&() const { return OverloadedAddressAux(); }
+  };
+
+  inline bool
+  operator<(const OverloadedAddress&, const OverloadedAddress&)
+  { return false; }
+
+  inline bool
+  operator==(const OverloadedAddress&, const OverloadedAddress&)
+  { return false; }
+
+  struct OverloadedAddress_hash
+  {
+    std::size_t
+    operator()(const OverloadedAddress&) const
+    { return 1; }
+  };
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+  struct NonCopyConstructible
+  {
+    NonCopyConstructible() : num(-1) { }
+
+    NonCopyConstructible(NonCopyConstructible&& other)
+    : num(other.num)
+    { other.num = 0; }
+
+    NonCopyConstructible(const NonCopyConstructible&) = delete;
+
+    operator int() { return num; }
+
+  private:
+    int num;
+  };
+#endif
+
+}
+
+#endif
diff --git a/libstdc++-v3/testsuite/util/testsuite_character.cc b/libstdc++-v3/testsuite/util/testsuite_character.cc
new file mode 100644
index 000000000..dba37c96d
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_character.cc
@@ -0,0 +1,186 @@
+// -*- C++ -*-
+
+// Utility subroutines for the C++ library testsuite. 
+//
+// Copyright (C) 2002, 2003, 2004, 2005, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+//
+
+#include <testsuite_character.h>
+
+namespace std
+{
+  locale::id
+  codecvt<__gnu_test::pod_uchar, char, __gnu_test::pod_state>::id;
+
+  locale::id 
+  ctype<__gnu_test::pod_uchar>::id;
+
+  locale::id
+  numpunct<__gnu_test::pod_uint>::id;
+
+  locale::id
+  moneypunct<__gnu_test::pod_uint>::id;
+
+  // Member specializations for the existing facet classes.  
+  // NB: This isn't especially portable. Perhaps a better way would be
+  // to just specialize all of numpunct and ctype.
+  using __gnu_test::pod_ushort;
+  typedef pod_ushort::value_type value_type;
+
+  template<>
+    bool 
+    ctype<pod_ushort>::
+    do_is(mask, char_type) const { return true; }
+
+  template<>
+    const pod_ushort*
+    ctype<pod_ushort>::
+    do_is(const char_type* __lo, const char_type*, mask*) const
+    { return __lo; }
+
+  template<>
+    const pod_ushort*
+    ctype<pod_ushort>::
+    do_scan_is(mask, const char_type* __lo, const char_type*) const
+    { return __lo; }
+
+  template<>
+    const pod_ushort*
+    ctype<pod_ushort>::
+    do_scan_not(mask, const char_type* __lo, const char_type*) const
+    { return __lo; }
+
+  template<>
+    pod_ushort 
+    ctype<pod_ushort>::
+    do_toupper(char_type __c) const
+    { return __c; }
+
+  template<>
+    const pod_ushort*
+    ctype<pod_ushort>::
+    do_toupper(char_type*, const char_type* __hi) const
+    { return __hi; }
+
+  template<>
+    pod_ushort 
+    ctype<pod_ushort>::
+    do_tolower(char_type __c) const
+    { return __c; }
+
+  template<>
+    const pod_ushort*
+    ctype<pod_ushort>::
+    do_tolower(char_type*, const char_type* __hi) const
+    { return __hi; }
+
+  template<>
+    pod_ushort
+    ctype<pod_ushort>::
+    do_widen(char __c) const
+    { 
+      char_type ret = { value_type(__c) };
+      return ret;
+    }
+
+  template<>
+    const char*
+    ctype<pod_ushort>::
+    do_widen(const char* __lo, const char* __hi, char_type* __dest) const
+    {
+      while (__lo < __hi)
+	{
+	  *__dest = this->do_widen(*__lo);
+	  ++__lo;
+	  ++__dest;
+	}
+      return __hi;
+    }
+
+  template<>
+    char
+    ctype<pod_ushort>::
+    do_narrow(char_type __wc, char) const
+    { return static_cast<char>(__wc.value); }
+
+  template<>
+    const pod_ushort*
+    ctype<pod_ushort>::
+    do_narrow(const pod_ushort* __lo, const pod_ushort* __hi, 
+	      char, char* __dest) const
+    {
+      while (__lo < __hi)
+	{
+	  *__dest = this->do_narrow(*__lo, char());
+	  ++__lo;
+	  ++__dest;
+	}
+      return __hi;
+    }
+
+  template<>
+    ctype<pod_ushort>::~ctype() { }
+
+  template<>
+    void
+    numpunct<pod_ushort>::_M_initialize_numpunct(__c_locale)
+    {
+      if (!_M_data)
+	_M_data = new __numpunct_cache<pod_ushort>;
+
+      _M_data->_M_grouping = "";
+      _M_data->_M_use_grouping = false;
+
+      _M_data->_M_decimal_point.value =  value_type('.');
+      _M_data->_M_thousands_sep.value = value_type(',');
+      
+      for (size_t i = 0; i < __num_base::_S_oend; ++i)
+	{
+	  value_type v = __num_base::_S_atoms_out[i];
+	  _M_data->_M_atoms_out[i].value = v;
+	}
+      _M_data->_M_atoms_out[__num_base::_S_oend] = pod_ushort();
+      
+      for (size_t j = 0; j < __num_base::_S_iend; ++j)
+	_M_data->_M_atoms_in[j].value = value_type(__num_base::_S_atoms_in[j]);
+      _M_data->_M_atoms_in[__num_base::_S_iend] = pod_ushort();
+
+      // "true"
+      pod_ushort* __truename = new pod_ushort[4 + 1];
+      __truename[0].value = value_type('t');
+      __truename[1].value = value_type('r');
+      __truename[2].value = value_type('u');
+      __truename[3].value = value_type('e');
+      __truename[4] = pod_ushort();
+      _M_data->_M_truename = __truename;
+
+      // "false"
+      pod_ushort* __falsename = new pod_ushort[5 + 1];
+      __falsename[0].value = value_type('f');
+      __falsename[1].value = value_type('a');
+      __falsename[2].value = value_type('l');
+      __falsename[3].value = value_type('s');
+      __falsename[4].value = value_type('e');
+      __falsename[5] = pod_ushort();
+      _M_data->_M_falsename = __falsename;
+    }
+
+  template<>
+    numpunct<pod_ushort>::~numpunct()
+    { delete _M_data; }
+} // namespace std
diff --git a/libstdc++-v3/testsuite/util/testsuite_character.h b/libstdc++-v3/testsuite/util/testsuite_character.h
new file mode 100644
index 000000000..ceda1f512
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_character.h
@@ -0,0 +1,570 @@
+// -*- C++ -*-
+
+// Testing character type and state type with char_traits and codecvt
+// specializations for the C++ library testsuite.
+//
+// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
+// 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+//
+
+#ifndef _GLIBCXX_TESTSUITE_CHARACTER_H
+#define _GLIBCXX_TESTSUITE_CHARACTER_H
+
+#include <climits>
+#include <string> // for char_traits
+#include <locale> // for codecvt
+#include <algorithm> // for transform
+#include <ext/pod_char_traits.h>
+
+namespace __gnu_test
+{  
+  struct pod_int
+  {
+    int value;
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+    // For std::iota.
+    pod_int&
+    operator++()
+    {
+      ++value;
+      return *this;
+    }
+#endif
+  };
+
+  // For 20.1 requirements for instantiable type: equality comparable
+  // and less than comparable.
+  inline bool
+  operator==(const pod_int& lhs, const pod_int& rhs)
+  { return lhs.value == rhs.value; }
+  
+  inline bool
+  operator<(const pod_int& lhs, const pod_int& rhs)
+  { return lhs.value < rhs.value; }
+
+  // For 26 numeric algorithms requirements, need addable,
+  // subtractable, multiplicable.
+  inline pod_int
+  operator+(const pod_int& lhs, const pod_int& rhs)
+  {
+    pod_int ret = { lhs.value + rhs.value };
+    return ret;
+  }
+
+  inline pod_int
+  operator-(const pod_int& lhs, const pod_int& rhs)
+  { 
+    pod_int ret = { lhs.value - rhs.value };
+    return ret;
+  }
+
+  inline pod_int
+  operator*(const pod_int& lhs, const pod_int& rhs)
+  { 
+    pod_int ret = { lhs.value * rhs.value };
+    return ret;
+  }
+
+  struct pod_state
+  {
+    unsigned long value;
+  };
+
+  inline bool
+  operator==(const pod_state& lhs, const pod_state& rhs)
+  { return lhs.value == rhs.value; }
+
+  inline bool
+  operator<(const pod_state& lhs, const pod_state& rhs)
+  { return lhs.value < rhs.value; }
+
+  // Alternate character types.
+  using __gnu_cxx::character;
+  typedef character<unsigned char, pod_int, pod_state>  	pod_char;
+  typedef character<unsigned char, unsigned int, pod_state>  	pod_uchar;
+  typedef character<unsigned short, unsigned int>	   	pod_ushort;
+  typedef character<unsigned int, unsigned long>	   	pod_uint;  
+}
+
+namespace __gnu_cxx 
+{
+  // Specializations.
+  // pod_char
+  template<>
+    template<typename V2>
+      inline __gnu_test::pod_char::char_type
+      __gnu_test::pod_char::char_type::from(const V2& v)
+      {
+	char_type ret = { static_cast<value_type>(v.value) };
+	return ret;
+      }
+
+  template<>
+    template<typename V2>
+      inline V2
+      __gnu_test::pod_char::char_type::to(const char_type& c)
+      {
+	V2 ret = { c.value };
+	return ret;
+      }
+  
+  template<>
+    template<typename V2>
+      inline __gnu_test::pod_uchar::char_type
+      __gnu_test::pod_uchar::char_type::from(const V2& v)
+      {
+	char_type ret;
+	ret.value = (v >> 5);
+	return ret;
+      }
+
+  template<>
+    template<typename V2>
+      inline V2
+      __gnu_test::pod_uchar::char_type::to(const char_type& c)
+      { return static_cast<V2>(c.value << 5); }
+} // namespace __gnu_test
+
+namespace std
+{
+  // codecvt specialization
+  //
+  // The conversion performed by the specialization is not supposed to
+  // be useful, rather it has been designed to demonstrate the
+  // essential features of stateful conversions:
+  // * Number and value of bytes for each internal character depends on the
+  //   state in addition to the character itself.
+  // * Unshift produces an unshift sequence and resets the state. On input
+  //   the unshift sequence causes the state to be reset.
+  //
+  // The conversion for output is as follows:
+  // 1. Calculate the value tmp by xor-ing the state and the internal
+  //    character
+  // 2. Split tmp into either two or three bytes depending on the value of
+  //    state. Output those bytes.
+  // 3. tmp becomes the new value of state.
+  template<>
+    class codecvt<__gnu_test::pod_uchar, char, __gnu_test::pod_state>
+    : public __codecvt_abstract_base<__gnu_test::pod_uchar, char, 
+				     __gnu_test::pod_state>
+    {
+    public:
+      typedef codecvt_base::result	result;
+      typedef __gnu_test::pod_uchar 	intern_type;
+      typedef char 			extern_type;
+      typedef __gnu_test::pod_state 	state_type;
+      typedef __codecvt_abstract_base<intern_type, extern_type, state_type>
+      base_type;
+
+      explicit codecvt(size_t refs = 0) : base_type(refs)
+      { }
+
+      static locale::id id;
+
+    protected:
+      ~codecvt()
+      { }
+
+      virtual result
+      do_out(state_type& state, const intern_type* from,
+	     const intern_type* from_end, const intern_type*& from_next,
+	     extern_type* to, extern_type* to_limit,
+	     extern_type*& to_next) const
+      {
+	while (from < from_end && to < to_limit)
+	  {
+	    unsigned char tmp = (state.value ^ from->value);
+	    if (state.value & 0x8)
+	      {
+		if (to >= to_limit - 2)
+		  break;
+		*to++ = (tmp & 0x7);
+		*to++ = ((tmp >> 3) & 0x7);
+		*to++ = ((tmp >> 6) & 0x3);
+	      }
+	    else
+	      {
+		if (to >= to_limit - 1)
+		  break;
+		*to++ = (tmp & 0xf);
+		*to++ = ((tmp >> 4) & 0xf);
+	      }
+	    state.value = tmp;
+	    ++from;
+	  }
+
+	from_next = from;
+	to_next = to;
+	return (from < from_end) ? partial : ok;
+      }
+
+      virtual result
+      do_in(state_type& state, const extern_type* from,
+	    const extern_type* from_end, const extern_type*& from_next,
+	    intern_type* to, intern_type* to_limit,
+	    intern_type*& to_next) const
+      {
+	while (from < from_end && to < to_limit)
+	  {
+	    unsigned char c = *from;
+	    if (c & 0xc0)
+	      {
+		// Unshift sequence
+		state.value &= c;
+		++from;
+		continue;
+	      }
+
+	    unsigned char tmp;
+	    if (state.value & 0x8)
+	      {
+		if (from >= from_end - 2)
+		  break;
+		tmp = (*from++ & 0x7);
+		tmp |= ((*from++ << 3) & 0x38);
+		tmp |= ((*from++ << 6) & 0xc0);
+	      }
+	    else
+	      {
+		if (from >= from_end - 1)
+		  break;
+		tmp = (*from++ & 0xf);
+		tmp |= ((*from++ << 4) & 0xf0);
+	      }
+	    to->value = (tmp ^ state.value);
+	    state.value = tmp;
+	    ++to;
+	  }
+
+	from_next = from;
+	to_next = to;
+	return (from < from_end) ? partial : ok;
+      }
+
+      virtual result
+      do_unshift(state_type& state, extern_type* to, extern_type* to_limit,
+		 extern_type*& to_next) const
+      {
+	for (unsigned int i = 0; i < CHAR_BIT; ++i)
+	  {
+	    unsigned int mask = (1 << i);
+	    if (state.value & mask)
+	      {
+		if (to == to_limit)
+		  {
+		    to_next = to;
+		    return partial;
+		  }
+
+		state.value &= ~mask;
+		*to++ = static_cast<unsigned char>(~mask);
+	      }
+	  }
+
+	to_next = to;
+	return state.value == 0 ? ok : error;
+      }
+
+      virtual int
+      do_encoding() const throw()
+      { return -1; }
+
+      virtual bool
+      do_always_noconv() const throw()
+      { return false; }
+
+      virtual int
+      do_length(state_type& state, const extern_type* from,
+		const extern_type* end, size_t max) const
+      {
+	const extern_type* beg = from;
+	while (from < end)
+	  {
+	    unsigned char c = *from;
+	    if (c & 0xc0)
+	      {
+		// Unshift sequence
+		state.value &= c;
+		++from;
+		continue;
+	      }
+	    
+	    if (max == 0) break;
+
+	    unsigned char tmp;
+	    if (state.value & 0x8)
+	      {
+		if (from >= end - 2)
+		  break;
+		tmp = (*from++ & 0x7);
+		tmp |= ((*from++ << 3) & 0x38);
+		tmp |= ((*from++ << 6) & 0xc0);
+	      }
+	    else
+	      {
+		if (from >= end - 1)
+		  break;
+		tmp = (*from++ & 0xf);
+		tmp |= ((*from++ << 4) & 0xf0);
+	      }
+	    state.value = tmp;
+	    --max;
+	  }
+	return from - beg;
+      }
+
+      // Maximum 8 bytes unshift sequence followed by max 3 bytes for
+      // one character.
+      virtual int
+      do_max_length() const throw()
+      { return 11; }
+    };
+
+  template<>
+    class ctype<__gnu_test::pod_uchar>
+    : public __ctype_abstract_base<__gnu_test::pod_uchar>
+    {
+    public:
+      typedef __gnu_test::pod_uchar char_type;
+
+      explicit ctype(size_t refs  = 0)
+      : __ctype_abstract_base<__gnu_test::pod_uchar>(refs) { }
+
+      static locale::id id;
+
+    protected:
+      ~ctype()
+      { }
+
+      virtual bool
+      do_is(mask, char_type) const
+      { return false; }
+
+      virtual const char_type*
+      do_is(const char_type* low, const char_type* high, mask* vec) const
+      {
+	fill_n(vec, high - low, mask());
+	return high;
+      }
+
+      virtual const char_type*
+      do_scan_is(mask, const char_type*, const char_type* high) const
+      { return high; }
+
+      virtual const char_type*
+      do_scan_not(mask, const char_type* low, const char_type*) const
+      { return low; }
+
+      virtual char_type
+      do_toupper(char_type c) const
+      { return c; }
+
+      virtual const char_type*
+      do_toupper(char_type*, const char_type*  high) const
+      { return high; }
+
+      virtual char_type
+      do_tolower(char_type c) const
+      { return c; }
+
+      virtual const char_type*
+      do_tolower(char_type*, const char_type*  high) const
+      { return high; }
+
+      virtual char_type
+      do_widen(char c) const
+      { return __gnu_test::pod_uchar::from<char>(c); }
+
+      virtual const char* 
+      do_widen(const char* low, const char* high, char_type* dest) const
+      {
+	transform(low, high, dest, &__gnu_test::pod_uchar::from<char>);
+	return high;
+      }
+
+      virtual char
+      do_narrow(char_type, char dfault) const
+      { return dfault; }
+
+      virtual const char_type*
+      do_narrow(const char_type* low, const char_type* high,
+		char dfault, char*  dest) const
+      {
+	fill_n(dest, high - low, dfault);
+	return high;
+      }
+    };
+
+  // numpunct specializations
+  template<> 
+    class numpunct<__gnu_test::pod_uint>
+    : public locale::facet
+    { 
+    public: 
+      typedef __gnu_test::pod_uint    char_type; 
+      typedef basic_string<char_type> string_type; 
+    
+      static locale::id id; 
+      
+      explicit
+      numpunct(size_t refs = 0)
+      : locale::facet(refs) 
+      { } 
+ 
+      char_type
+      decimal_point() const 
+      { return this->do_decimal_point(); } 
+ 
+      char_type
+      thousands_sep() const 
+      { return this->do_thousands_sep(); } 
+ 
+      string
+      grouping() const 
+      { return this->do_grouping(); } 
+ 
+      string_type
+      truename() const 
+      { return this->do_truename(); } 
+ 
+      string_type
+      falsename() const 
+      { return this->do_falsename(); } 
+ 
+    protected: 
+      ~numpunct()
+      { } 
+ 
+      virtual char_type
+      do_decimal_point() const 
+      { return char_type(); } 
+ 
+      virtual char_type
+      do_thousands_sep() const 
+      { return char_type(); } 
+ 
+      virtual string
+      do_grouping() const 
+      { return string(); } 
+ 
+      virtual string_type
+      do_truename() const 
+      { return string_type(); }
+ 
+      virtual string_type
+      do_falsename() const 
+      { return string_type(); } 
+    };
+
+  template<> 
+    class moneypunct<__gnu_test::pod_uint>
+    : public locale::facet, public money_base
+    { 
+    public: 
+      typedef __gnu_test::pod_uint    char_type; 
+      typedef basic_string<char_type> string_type; 
+    
+      static locale::id id; 
+      static const bool intl = false;
+
+      explicit
+      moneypunct(size_t refs = 0)
+      : locale::facet(refs) 
+      { }
+ 
+      char_type
+      decimal_point() const 
+      { return this->do_decimal_point(); } 
+ 
+      char_type
+      thousands_sep() const 
+      { return this->do_thousands_sep(); }
+
+      string
+      grouping() const
+      { return this->do_grouping(); }
+
+      string_type
+      curr_symbol() const 
+      { return this->do_curr_symbol(); } 
+ 
+      string_type
+      positive_sign() const 
+      { return this->do_positive_sign(); } 
+
+      string_type
+      negative_sign() const 
+      { return this->do_negative_sign(); } 
+      
+      int
+      frac_digits() const
+      { return this->do_frac_digits(); }
+
+      pattern
+      pos_format() const
+      { return this->do_pos_format(); }
+ 
+      pattern
+      neg_format() const
+      { return this->do_neg_format(); }
+  
+    protected: 
+      ~moneypunct() 
+      { } 
+ 
+      virtual char_type
+      do_decimal_point() const 
+      { return char_type(); } 
+ 
+      virtual char_type
+      do_thousands_sep() const 
+      { return char_type(); } 
+ 
+      virtual string
+      do_grouping() const 
+      { return string(); }
+
+      virtual string_type
+      do_curr_symbol() const 
+      { return string_type(); } 
+ 
+      string_type
+      do_positive_sign() const 
+      { return string_type(); } 
+
+      string_type
+      do_negative_sign() const 
+      { return string_type(); } 
+      
+      int
+      do_frac_digits() const
+      { return 0; }
+
+      pattern
+      do_pos_format() const
+      { return pattern(); }
+ 
+      pattern
+      do_neg_format() const
+      { return pattern(); }
+     };
+} // namespace std
+
+#endif // _GLIBCXX_TESTSUITE_CHARACTER_H
+
diff --git a/libstdc++-v3/testsuite/util/testsuite_common_types.h b/libstdc++-v3/testsuite/util/testsuite_common_types.h
new file mode 100644
index 000000000..a4f59ac2a
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_common_types.h
@@ -0,0 +1,833 @@
+// -*- C++ -*-
+// typelist for the C++ library testsuite. 
+//
+// Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+// 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+//
+
+#ifndef _TESTSUITE_COMMON_TYPES_H
+#define _TESTSUITE_COMMON_TYPES_H 1
+
+#include <ext/typelist.h>
+
+#include <ext/new_allocator.h>
+#include <ext/malloc_allocator.h>
+#include <ext/mt_allocator.h>
+#include <ext/bitmap_allocator.h>
+#include <ext/pool_allocator.h>
+
+#include <algorithm>
+
+#include <vector>
+#include <list>
+#include <deque>
+#include <string>
+#include <limits>
+
+#include <map>
+#include <set>
+#include <tr1/functional>
+#include <tr1/unordered_map>
+#include <tr1/unordered_set>
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+#include <atomic>
+#include <type_traits>
+#endif
+
+namespace __gnu_test
+{
+  using __gnu_cxx::typelist::node;
+  using __gnu_cxx::typelist::transform;
+  using __gnu_cxx::typelist::append;
+
+  // All the allocators to test.
+  template<typename Tp, bool Thread>
+    struct allocator_policies
+    {
+      typedef Tp			    	value_type;
+      typedef __gnu_cxx::new_allocator<Tp> 		a1;
+      typedef __gnu_cxx::malloc_allocator<Tp> 		a2;
+      typedef __gnu_cxx::__common_pool_policy<__gnu_cxx::__pool, Thread> pool_policy;
+      typedef __gnu_cxx::__mt_alloc<Tp, pool_policy>	a3;
+      typedef __gnu_cxx::bitmap_allocator<Tp> 		a4;
+      typedef __gnu_cxx::__pool_alloc<Tp> 		a5;
+      typedef node<_GLIBCXX_TYPELIST_CHAIN5(a1, a2, a3, a4, a5)> type;
+    };
+
+  // Typelists for vector, string, list, deque.
+  // XXX should just use template templates
+  template<typename Tp, bool Thread>
+    struct vectors
+    {
+      typedef Tp			    		value_type;
+
+      template<typename Tl>
+        struct vector_shell
+	{
+	  typedef Tl 					allocator_type;
+	  typedef std::vector<value_type, allocator_type>	type;
+	};
+
+      typedef allocator_policies<value_type, Thread>	allocator_types;
+      typedef typename allocator_types::type 		allocator_typelist;
+      typedef typename transform<allocator_typelist, vector_shell>::type type;
+    };
+
+  template<typename Tp, bool Thread>
+    struct lists
+    {
+      typedef Tp			    		value_type;
+
+      template<typename Tl>
+        struct list_shell
+	{
+	  typedef Tl 					allocator_type;
+	  typedef std::list<value_type, allocator_type>	type;
+	};
+
+      typedef allocator_policies<value_type, Thread>	allocator_types;
+      typedef typename allocator_types::type 		allocator_typelist;
+      typedef typename transform<allocator_typelist, list_shell>::type type;
+    };
+
+  template<typename Tp, bool Thread>
+    struct deques
+    {
+      typedef Tp			    		value_type;
+
+      template<typename Tl>
+        struct deque_shell
+	{
+	  typedef Tl 					allocator_type;
+	  typedef std::deque<value_type, allocator_type>	type;
+	};
+
+      typedef allocator_policies<value_type, Thread>	allocator_types;
+      typedef typename allocator_types::type 		allocator_typelist;
+      typedef typename transform<allocator_typelist, deque_shell>::type type;
+    };
+
+  template<typename Tp, bool Thread>
+    struct strings
+    {
+      typedef Tp			    		value_type;
+
+      template<typename Tl>
+        struct string_shell
+	{
+	  typedef Tl 					allocator_type;
+	  typedef std::char_traits<value_type> 		traits_type;
+	  typedef std::basic_string<value_type, traits_type, allocator_type>	type;
+	};
+
+      typedef allocator_policies<value_type, Thread>	allocator_types;
+      typedef typename allocator_types::type 		allocator_typelist;
+      typedef typename transform<allocator_typelist, string_shell>::type type;
+    };
+
+  // A typelist of vector, list, deque, and string all instantiated
+  // with each of the allocator policies.
+  template<typename Tp, bool Thread>
+    struct sequence_containers
+    {
+      typedef Tp			    		value_type;
+
+      typedef typename vectors<value_type, Thread>::type vector_typelist;
+      typedef typename lists<value_type, Thread>::type   list_typelist;
+      typedef typename deques<value_type, Thread>::type  deque_typelist;
+      typedef typename strings<value_type, Thread>::type string_typelist;
+
+      typedef typename append<vector_typelist, list_typelist>::type a1;
+      typedef typename append<deque_typelist, string_typelist>::type a2;
+      typedef typename append<a1, a2>::type type;
+    };
+
+  // Typelists for map, set, unordered_set, unordered_map.
+  template<typename Tp, bool Thread>
+    struct maps
+    {
+      typedef Tp			    		value_type;
+      typedef Tp 					key_type;
+      typedef std::pair<const key_type, value_type> 	pair_type;
+      typedef std::less<key_type>      			compare_function;
+
+      template<typename Tl>
+        struct container
+	{
+	  typedef Tl 					allocator_type;
+	  typedef std::map<key_type, value_type, compare_function, allocator_type>	type;
+	};
+
+      typedef allocator_policies<pair_type, Thread>	allocator_types;
+      typedef typename allocator_types::type 		allocator_typelist;
+      typedef typename transform<allocator_typelist, container>::type type;
+    };
+
+  template<typename Tp, bool Thread>
+    struct unordered_maps
+    {
+      typedef Tp			    		value_type;
+      typedef Tp 					key_type;
+      typedef std::pair<const key_type, value_type> 	pair_type;
+      typedef std::tr1::hash<key_type>      		hash_function;
+      typedef std::equal_to<key_type>      		equality_function;
+
+      template<typename Tl>
+        struct container
+	{
+	  typedef Tl 					allocator_type;
+	  typedef std::tr1::unordered_map<key_type, value_type, hash_function, equality_function, allocator_type>	type;
+	};
+
+      typedef allocator_policies<pair_type, Thread>	allocator_types;
+      typedef typename allocator_types::type 		allocator_typelist;
+      typedef typename transform<allocator_typelist, container>::type type;
+    };
+
+  template<typename Tp, bool Thread>
+    struct sets
+    {
+      typedef Tp			    		value_type;
+      typedef Tp 					key_type;
+      typedef std::less<key_type>      			compare_function;
+
+      template<typename Tl>
+        struct container
+	{
+	  typedef Tl 					allocator_type;
+	  typedef std::set<key_type, compare_function, allocator_type>	type;
+	};
+
+      typedef allocator_policies<key_type, Thread>	allocator_types;
+      typedef typename allocator_types::type 		allocator_typelist;
+      typedef typename transform<allocator_typelist, container>::type type;
+    };
+
+  template<typename Tp, bool Thread>
+    struct unordered_sets
+    {
+      typedef Tp			    		value_type;
+      typedef Tp 					key_type;
+      typedef std::tr1::hash<key_type>      		hash_function;
+      typedef std::equal_to<key_type>      		equality_function;
+
+      template<typename Tl>
+        struct container
+	{
+	  typedef Tl 					allocator_type;
+	  typedef std::tr1::unordered_set<key_type, hash_function, equality_function, allocator_type>	type;
+	};
+
+      typedef allocator_policies<key_type, Thread>	allocator_types;
+      typedef typename allocator_types::type 		allocator_typelist;
+      typedef typename transform<allocator_typelist, container>::type type;
+    };
+
+
+  // A typelist  of all associated  container types, with each  of the
+  // allocator policies.
+  template<typename Tp, bool Thread>
+    struct associative_containers
+    {
+      typedef Tp			    		value_type;
+
+      typedef typename maps<value_type, Thread>::type map_typelist;
+      typedef typename sets<value_type, Thread>::type set_typelist;
+      typedef typename unordered_maps<value_type, Thread>::type unordered_map_typelist;
+      typedef typename unordered_sets<value_type, Thread>::type unordered_set_typelist;
+
+      typedef typename append<map_typelist, unordered_map_typelist>::type a1;
+      typedef typename append<set_typelist, unordered_set_typelist>::type a2;
+      typedef typename append<a1, a2>::type type;
+    };
+
+  // A typelist of all integral types.
+  struct integral_types
+  {
+    typedef bool 		a1;
+    typedef char 		a2;
+    typedef signed char 	a3;
+    typedef unsigned char 	a4;
+    typedef short 		a5;
+    typedef unsigned short 	a6;
+    typedef int 		a7;
+    typedef unsigned int 	a8;
+    typedef long 		a9;
+    typedef unsigned long 	a10;
+    typedef long long 		a11;
+    typedef unsigned long long 	a12;
+    typedef wchar_t 		a13;
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+    typedef char16_t 		a14;
+    typedef char32_t 		a15;
+
+    typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9, 
+					   a10, a11, a12, a13, a14, a15)> type;
+#else
+    typedef node<_GLIBCXX_TYPELIST_CHAIN13(a1, a2, a3, a4, a5, a6, a7, a8, a9, 
+					   a10, a11, a12, a13)> type;
+#endif
+  };
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+  struct atomic_integrals_no_bool
+  {
+    typedef std::atomic_char        	a2;
+    typedef std::atomic_schar 		a3;
+    typedef std::atomic_uchar 		a4;
+    typedef std::atomic_short       	a5;
+    typedef std::atomic_ushort 		a6;
+    typedef std::atomic_int 		a7;
+    typedef std::atomic_uint 		a8;
+    typedef std::atomic_long        	a9;
+    typedef std::atomic_ulong 		a10;
+    typedef std::atomic_llong       	a11;
+    typedef std::atomic_ullong 		a12;
+    typedef std::atomic_wchar_t     	a13;
+    typedef std::atomic_char16_t    	a14;
+    typedef std::atomic_char32_t    	a15;
+    
+    typedef node<_GLIBCXX_TYPELIST_CHAIN14(a2, a3, a4, a5, a6, a7, a8, a9, 
+					   a10, a11, a12, a13, a14, a15)> type;
+  };
+
+  struct atomic_integrals
+  {
+    typedef std::atomic_bool        	a1;
+    typedef std::atomic_char        	a2;
+    typedef std::atomic_schar 		a3;
+    typedef std::atomic_uchar 		a4;
+    typedef std::atomic_short       	a5;
+    typedef std::atomic_ushort 		a6;
+    typedef std::atomic_int 		a7;
+    typedef std::atomic_uint 		a8;
+    typedef std::atomic_long        	a9;
+    typedef std::atomic_ulong 		a10;
+    typedef std::atomic_llong       	a11;
+    typedef std::atomic_ullong 		a12;
+    typedef std::atomic_wchar_t     	a13;
+    typedef std::atomic_char16_t    	a14;
+    typedef std::atomic_char32_t    	a15;
+    
+    typedef node<_GLIBCXX_TYPELIST_CHAIN15(a1, a2, a3, a4, a5, a6, a7, a8, a9, 
+					   a10, a11, a12, a13, a14, a15)> type;
+  };
+
+
+  template<typename Tp>
+    struct atomics
+    {
+      typedef Tp			value_type;
+      typedef std::atomic<value_type>	type;
+    };
+
+  typedef transform<integral_types::type, atomics>::type atomics_tl;
+#endif
+
+  template<typename Tp>
+    struct numeric_limits
+    {
+      typedef Tp			value_type;
+      typedef std::numeric_limits<value_type>	type;
+    };
+
+  typedef transform<integral_types::type, numeric_limits>::type limits_tl;
+
+  struct has_increment_operators
+  {
+    template<typename _Tp>
+      void 
+      operator()()
+      {
+	struct _Concept
+	{
+	  void __constraint()
+	  {
+	    _Tp a; 
+	    ++a; // prefix
+	    a++; // postfix
+	    a += a;
+	  }
+	};
+
+	void (_Concept::*__x)() __attribute__((unused))
+	  = &_Concept::__constraint;
+      }
+  };
+
+  struct has_decrement_operators
+  {
+    template<typename _Tp>
+      void 
+      operator()()
+      {
+	struct _Concept
+	{
+	  void __constraint()
+	  {
+	    _Tp a; 
+	    --a; // prefix
+	    a--; // postfix
+	    a -= a;
+	  }
+	};
+
+	void (_Concept::*__x)() __attribute__((unused))
+	  = &_Concept::__constraint;
+      }
+  };
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+  template<typename _Tp>
+    void
+    constexpr_bitwise_operators()
+    {
+      constexpr _Tp a = _Tp();
+      constexpr _Tp b = _Tp();
+      constexpr _Tp c1 __attribute__((unused)) = a | b;
+      constexpr _Tp c2 __attribute__((unused)) = a & b;
+      constexpr _Tp c3 __attribute__((unused)) = a ^ b;
+      constexpr _Tp c4 __attribute__((unused)) = ~b;
+    }
+#endif
+
+  template<typename _Tp>
+    void
+    bitwise_operators()
+    {
+      _Tp a = _Tp();
+      _Tp b = _Tp();
+      a | b;
+      a & b;
+      a ^ b;
+      ~b;
+    }
+
+  template<typename _Tp>
+    void
+    bitwise_assignment_operators()
+    {
+      _Tp a = _Tp();
+      _Tp b = _Tp();
+      a |= b; // set
+      a &= ~b; // clear
+      a ^= b;
+    }
+
+  // 17.3.2.1.2 - Bitmask types [lib.bitmask.types]
+  // bitmask_operators
+  template<typename _BitmTp>
+    void
+    bitmask_operators()
+    {
+      bitwise_operators<_BitmTp>();
+      bitwise_assignment_operators<_BitmTp>();
+    }
+
+  struct has_bitwise_operators
+  {
+    template<typename _Tp>
+      void 
+      operator()()
+      {
+	struct _Concept
+	{
+	  void __constraint()
+	  {
+	    a |= b; // set
+	    a &= ~b; // clear
+	    a ^= b;
+	  }
+	  _Tp a;
+	  _Tp b;
+	};
+
+	void (_Concept::*__x)() __attribute__((unused))
+	  = &_Concept::__constraint;
+      }
+  };
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+
+  struct constexpr_comparison_eq_ne
+  {
+    template<typename _Tp1, typename _Tp2 = _Tp1>
+      void 
+      operator()()
+      {
+	static_assert(_Tp1() == _Tp2(), "eq");
+	static_assert(!(_Tp1() != _Tp2()), "ne");
+      }
+  };
+
+  struct constexpr_comparison_operators
+  {
+    template<typename _Tp>
+      void 
+      operator()()
+      {
+	static_assert(!(_Tp() < _Tp()), "less");
+	static_assert(_Tp() <= _Tp(), "leq");
+	static_assert(!(_Tp() > _Tp()), "more");
+	static_assert(_Tp() >= _Tp(), "meq");
+	static_assert(_Tp() == _Tp(), "eq");
+	static_assert(!(_Tp() != _Tp()), "ne");
+      }
+  };
+
+  // Generator to test standard layout
+  struct has_trivial_cons_dtor
+  {
+    template<typename _Tp>
+      void 
+      operator()()
+      {
+	struct _Concept
+	{
+	  void __constraint()
+	  {
+	    typedef std::has_trivial_default_constructor<_Tp> ctor_p;
+	    static_assert(ctor_p::value, "default constructor not trivial");
+
+	    typedef std::has_trivial_destructor<_Tp> dtor_p;
+	    static_assert(dtor_p::value, "destructor not trivial");
+	  }
+	};
+
+	void (_Concept::*__x)() __attribute__((unused))
+	  = &_Concept::__constraint;
+      }
+  };
+
+  struct standard_layout
+  {
+    template<typename _Tp>
+      void 
+      operator()()
+      {
+	struct _Concept
+	{
+	  void __constraint()
+	  {
+	    typedef std::is_standard_layout<_Tp> standard_layout_p;
+	    static_assert(standard_layout_p::value, "not standard_layout");
+	  }
+	};
+
+	void (_Concept::*__x)() __attribute__((unused))
+	  = &_Concept::__constraint;
+      }
+  };
+#endif
+
+  // Generator to test base class
+  struct has_required_base_class
+  {
+    template<typename _TBase, typename _TDerived>
+      void 
+      operator()()
+      {
+	struct _Concept
+	{
+	  void __constraint()
+	  {
+	    const _TDerived& obj = __a;
+	    const _TBase* base __attribute__((unused)) = &obj;
+	  }
+	  
+	  _TDerived __a;
+	};
+
+	void (_Concept::*__x)() __attribute__((unused))
+	  = &_Concept::__constraint;
+      }
+  };
+
+  // Generator to test assignment operator.
+  struct assignable
+  {
+    template<typename _Tp>
+      void 
+      operator()()
+      {
+	struct _Concept
+	{
+	  void __constraint()
+	  { __v1 = __v2; }
+
+	  _Tp __v1;
+	  _Tp __v2;
+	};
+
+	void (_Concept::*__x)() __attribute__((unused))
+	  = &_Concept::__constraint;
+      }
+  };
+
+  // Generator to test default constructor.
+  struct default_constructible
+  {
+    template<typename _Tp>
+      void 
+      operator()()
+      {
+	struct _Concept
+	{
+	  void __constraint()
+	  { _Tp __v __attribute__((unused)); }
+	};
+
+	void (_Concept::*__x)() __attribute__((unused))
+	  = &_Concept::__constraint;
+      }
+  };
+
+  // Generator to test copy constructor.
+  struct copy_constructible
+  {
+    template<typename _Tp>
+      void 
+      operator()()
+      {
+	struct _Concept
+	{
+	  void __constraint()
+	  { _Tp __v2(__v1); }
+
+	  _Tp __v1;
+	};
+
+	void (_Concept::*__x)() __attribute__((unused))
+	  = &_Concept::__constraint;
+      }
+  };
+
+  // Generator to test direct initialization, single value constructor.
+  struct single_value_constructible
+  {
+    template<typename _Ttype, typename _Tvalue>
+      void 
+      operator()()
+      {
+	struct _Concept
+	{
+	  void __constraint()
+	  { _Ttype __v(__a); }
+	  
+	  _Tvalue __a;
+	};
+
+	void (_Concept::*__x)() __attribute__((unused))
+	  = &_Concept::__constraint;
+      }
+  };
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+  // Generator to test default constructor.
+  struct constexpr_default_constructible
+  {
+    template<typename _Tp, bool _IsLitp = std::is_literal_type<_Tp>::value>
+      struct _Concept;
+
+    // NB: _Tp must be a literal type.
+    // Have to have user-defined default ctor for this to work.
+    template<typename _Tp>
+      struct _Concept<_Tp, true>
+      {
+	void __constraint()
+	{ constexpr _Tp __obj; }
+      };
+
+    // Non-literal type, declare local static and verify no
+    // constructors generated for _Tp within the translation unit.
+    template<typename _Tp>
+      struct _Concept<_Tp, false>
+      {
+	void __constraint()
+	{ static _Tp __obj; }
+      };
+
+    template<typename _Tp>
+      void 
+      operator()()
+      {
+	_Concept<_Tp> c;
+	c.__constraint();
+      }
+  };
+
+  // Generator to test defaulted default constructor.
+  struct constexpr_defaulted_default_constructible
+  {
+    template<typename _Tp>
+      void
+      operator()()
+      {
+	struct _Concept
+	{
+	  void __constraint()
+	  { constexpr _Tp __v __attribute__((unused)) { }; }
+	};
+
+	void (_Concept::*__x)() __attribute__((unused))
+	  = &_Concept::__constraint;
+      }
+  };
+
+  struct constexpr_single_value_constructible
+  {
+    template<typename _Ttesttype, typename _Tvaluetype, 
+	     bool _IsLitp = std::is_literal_type<_Ttesttype>::value>
+      struct _Concept;
+
+    // NB: _Tvaluetype and _Ttesttype must be literal types.
+    // Additional constraint on _Tvaluetype needed.  Either assume
+    // user-defined default ctor as per
+    // constexpr_default_constructible and provide no initializer,
+    // provide an initializer, or assume empty-list init-able. Choose
+    // the latter.
+    template<typename _Ttesttype, typename _Tvaluetype>
+      struct _Concept<_Ttesttype, _Tvaluetype, true>
+      {
+	void __constraint()
+	{
+	  constexpr _Tvaluetype __v { };
+	  constexpr _Ttesttype __obj(__v);
+	}
+      };
+
+    template<typename _Ttesttype, typename _Tvaluetype>
+      struct _Concept<_Ttesttype, _Tvaluetype, false>
+      {
+	void __constraint()
+	{ 
+	  const _Tvaluetype __v { };
+	  static _Ttesttype __obj(__v);
+	}
+      };
+
+    template<typename _Ttesttype, typename _Tvaluetype>
+      void
+      operator()()
+      {
+	_Concept<_Ttesttype, _Tvaluetype> c;
+	c.__constraint();
+      }
+  };
+#endif
+
+  // Generator to test direct list initialization
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+  struct direct_list_initializable
+  {
+    template<typename _Ttype, typename _Tvalue>
+      void 
+      operator()()
+      {
+	struct _Concept
+	{
+	  void __constraint()
+	  { 
+	    _Ttype __v1 { }; // default ctor
+	    _Ttype __v2 { __a };  // single-argument ctor
+	  }
+	  
+	  _Tvalue __a;
+	};
+
+	void (_Concept::*__x)() __attribute__((unused))
+	  = &_Concept::__constraint;
+      }
+  };
+#endif
+
+  // Generator to test copy list initialization, aggregate initialization
+  struct copy_list_initializable
+  {
+    template<typename _Ttype, typename _Tvalue>
+      void 
+      operator()()
+      {
+	struct _Concept
+	{
+	  void __constraint()
+	  { _Ttype __v __attribute__((unused)) = {__a}; }
+	  
+	  _Tvalue __a;
+	};
+
+	void (_Concept::*__x)() __attribute__((unused))
+	  = &_Concept::__constraint;
+      }
+  };
+
+  // Generator to test integral conversion operator
+  struct integral_convertable
+  {
+    template<typename _Ttype, typename _Tvalue>
+      void 
+      operator()()
+      {
+	struct _Concept
+	{
+	  void __constraint()
+	  {
+	    _Tvalue __v0(0);
+	    _Tvalue __v1(1);
+	    _Ttype __a(__v1);
+	    __v0 = __a;
+
+	    bool test __attribute__((unused)) = true;
+	    VERIFY( __v1 == __v0 );
+	  }
+	};
+
+	void (_Concept::*__x)() __attribute__((unused))
+	  = &_Concept::__constraint;
+      }
+  };
+
+  // Generator to test integral assignment operator 
+  struct integral_assignable
+  {
+    template<typename _Ttype, typename _Tvalue>
+      void 
+      operator()()
+      {
+	struct _Concept
+	{
+	  void __constraint()
+	  {
+	    _Tvalue __v0(0);
+	    _Tvalue __v1(1);
+	    _Ttype __a(__v0);
+	    __a = __v1;
+	    _Tvalue __vr = __a;
+
+	    bool test __attribute__((unused)) = true;
+	    VERIFY( __v1 == __vr );
+	  }
+	};
+
+	void (_Concept::*__x)() __attribute__((unused))
+	  = &_Concept::__constraint;
+      }
+  };
+} // namespace __gnu_test
+#endif
diff --git a/libstdc++-v3/testsuite/util/testsuite_container_traits.h b/libstdc++-v3/testsuite/util/testsuite_container_traits.h
new file mode 100644
index 000000000..4d8ff997a
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_container_traits.h
@@ -0,0 +1,260 @@
+// -*- C++ -*-
+
+// Copyright (C) 2009, 2010 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#ifndef _GLIBCXX_TESTSUITE_CONTAINER_TRAITS_H
+#define _GLIBCXX_TESTSUITE_CONTAINER_TRAITS_H
+
+#include <bits/stdc++.h>
+#include <ext/vstring.h>
+
+namespace __gnu_test
+{
+  // Container traits.
+  // Base class with default false values for all traits.
+  struct traits_base
+  {
+    // Type, nested type, and typedef related traits.
+    typedef std::false_type	is_container;
+    typedef std::false_type	is_adaptor;
+    typedef std::false_type	is_reversible;
+    typedef std::false_type	is_allocator_aware;
+    typedef std::false_type	is_associative;
+    typedef std::false_type	is_unordered;
+    typedef std::false_type	is_mapped;
+
+    typedef std::false_type	has_erase;
+    typedef std::false_type	has_erase_after;
+    typedef std::false_type	has_throwing_erase;
+    typedef std::false_type	has_insert;
+    typedef std::false_type	has_insert_after;
+    typedef std::false_type	has_push_pop;
+    typedef std::false_type	has_size_type_constructor;
+  };
+
+  // Primary template does nothing. Specialize on each type under
+  // test, derive off of traits_base and just add the true traits.
+  template<typename _Tp>
+    struct traits;
+
+  // Specialize for each container.
+  template<typename _Tp, size_t _Np>
+    struct traits<std::array<_Tp, _Np>> : public traits_base
+    {
+      typedef std::true_type	is_container;
+      typedef std::true_type	is_reversible;
+    };
+
+  template<typename _Tp1, typename _Tp2>
+    struct traits<std::deque<_Tp1, _Tp2>> : public traits_base
+    {
+      typedef std::true_type	is_container;
+      typedef std::true_type	is_reversible;
+      typedef std::true_type	is_allocator_aware;
+
+      typedef std::true_type	has_erase;
+      typedef std::true_type	has_throwing_erase;
+      typedef std::true_type	has_insert;
+      typedef std::true_type	has_push_pop;
+      typedef std::true_type	has_size_type_constructor;
+    };
+
+  template<typename _Tp1, typename _Tp2>
+    struct traits<std::forward_list<_Tp1, _Tp2>> : public traits_base
+    {
+      typedef std::true_type	is_container;
+      typedef std::true_type	is_allocator_aware;
+
+      typedef std::true_type	has_erase_after;
+      typedef std::true_type	has_insert_after;
+      typedef std::true_type	has_push_pop;
+      typedef std::true_type	has_size_type_constructor;
+    };
+
+  template<typename _Tp1, typename _Tp2>
+    struct traits<std::list<_Tp1, _Tp2>> : public traits_base
+    {
+      typedef std::true_type	is_container;
+      typedef std::true_type	is_reversible;
+      typedef std::true_type	is_allocator_aware;
+
+      typedef std::true_type	has_erase;
+      typedef std::true_type	has_insert;
+      typedef std::true_type	has_push_pop;
+      typedef std::true_type	has_size_type_constructor;
+    };
+
+  template<typename _Tp1, typename _Tp2>
+    struct traits<std::vector<_Tp1, _Tp2>> : public traits_base
+    {
+      typedef std::true_type    is_container;
+      typedef std::true_type    is_reversible;
+      typedef std::true_type    is_allocator_aware;
+
+      typedef std::true_type	has_erase;
+      typedef std::true_type	has_throwing_erase;
+      typedef std::true_type	has_insert;
+      typedef std::true_type	has_size_type_constructor;
+    };
+
+  template<typename _Tp1, typename _Tp2, typename _Tp3>
+    struct traits<std::basic_string<_Tp1, _Tp2, _Tp3>> : public traits_base
+    {
+      typedef std::true_type    is_container;
+      typedef std::true_type    is_reversible;
+      typedef std::true_type    is_allocator_aware;
+
+      typedef std::true_type	has_erase;
+      typedef std::true_type	has_insert;
+    };
+
+  template<typename _Tp1, typename _Tp2, typename _Tp3,
+	   template <typename, typename, typename> class _Tp4>
+    struct traits<__gnu_cxx::__versa_string<_Tp1, _Tp2, _Tp3, _Tp4>>
+    : public traits_base
+    {
+      typedef std::true_type    is_container;
+      typedef std::true_type    is_reversible;
+      typedef std::true_type    is_allocator_aware;
+
+      typedef std::true_type	has_erase;
+      typedef std::true_type	has_insert;
+    };
+
+  template<typename _Tp1, typename _Tp2, typename _Tp3, typename _Tp4>
+    struct traits<std::map<_Tp1, _Tp2, _Tp3, _Tp4>> : public traits_base
+    {
+      typedef std::true_type	is_container;
+      typedef std::true_type	is_reversible;
+      typedef std::true_type	is_allocator_aware;
+      typedef std::true_type	is_associative;
+      typedef std::true_type	is_mapped;
+
+      typedef std::true_type	has_erase;
+      typedef std::true_type	has_insert;
+    };
+
+  template<typename _Tp1, typename _Tp2, typename _Tp3, typename _Tp4>
+    struct traits<std::multimap<_Tp1, _Tp2, _Tp3, _Tp4>> : public traits_base
+    {
+      typedef std::true_type	is_container;
+      typedef std::true_type	is_reversible;
+      typedef std::true_type	is_allocator_aware;
+      typedef std::true_type	is_associative;
+      typedef std::true_type	is_mapped;
+
+      typedef std::true_type	has_erase;
+      typedef std::true_type	has_insert;
+    };
+
+  template<typename _Tp1, typename _Tp2, typename _Tp3>
+    struct traits<std::set<_Tp1, _Tp2, _Tp3>> : public traits_base
+    {
+      typedef std::true_type	is_container;
+      typedef std::true_type	is_reversible;
+      typedef std::true_type	is_allocator_aware;
+      typedef std::true_type	is_associative;
+
+      typedef std::true_type	has_erase;
+      typedef std::true_type	has_insert;
+    };
+
+  template<typename _Tp1, typename _Tp2, typename _Tp3>
+    struct traits<std::multiset<_Tp1, _Tp2, _Tp3>> : public traits_base
+    {
+      typedef std::true_type	is_container;
+      typedef std::true_type	is_reversible;
+      typedef std::true_type	is_allocator_aware;
+      typedef std::true_type	is_associative;
+
+      typedef std::true_type	has_erase;
+      typedef std::true_type	has_insert;
+    };
+
+  template<typename _Tp1, typename _Tp2>
+    struct traits<std::priority_queue<_Tp1, _Tp2>> : public traits_base
+    {
+      typedef std::true_type	is_adaptor;
+    };
+
+  template<typename _Tp1, typename _Tp2>
+    struct traits<std::queue<_Tp1, _Tp2>> : public traits_base
+    {
+      typedef std::true_type	is_adaptor;
+    };
+
+  template<typename _Tp1, typename _Tp2>
+    struct traits<std::stack<_Tp1, _Tp2> > : public traits_base
+    {
+      typedef std::true_type	is_adaptor;
+    };
+
+  template<typename _Tp1, typename _Tp2, typename _Tp3,
+	   typename _Tp4, typename _Tp5>
+    struct traits<std::unordered_map<_Tp1, _Tp2, _Tp3, _Tp4, _Tp5>>
+    : public traits_base
+    {
+      typedef std::true_type	is_container;
+      typedef std::true_type	is_allocator_aware;
+      typedef std::true_type	is_unordered;
+      typedef std::true_type	is_mapped;
+
+      typedef std::true_type	has_erase;
+      typedef std::true_type	has_insert;
+    };
+
+  template<typename _Tp1, typename _Tp2, typename _Tp3,
+	   typename _Tp4, typename _Tp5>
+    struct traits<std::unordered_multimap<_Tp1, _Tp2, _Tp3, _Tp4, _Tp5>>
+    : public traits_base
+    {
+      typedef std::true_type	is_container;
+      typedef std::true_type	is_allocator_aware;
+      typedef std::true_type	is_unordered;
+      typedef std::true_type	is_mapped;
+
+      typedef std::true_type	has_erase;
+      typedef std::true_type	has_insert;
+    };
+
+  template<typename _Tp1, typename _Tp2, typename _Tp3, typename _Tp4>
+    struct traits<std::unordered_multiset<_Tp1, _Tp2, _Tp3, _Tp4>>
+    : public traits_base
+    {
+      typedef std::true_type	is_container;
+      typedef std::true_type	is_allocator_aware;
+      typedef std::true_type	is_unordered;
+
+      typedef std::true_type	has_erase;
+      typedef std::true_type	has_insert;
+    };
+
+  template<typename _Tp1, typename _Tp2, typename _Tp3, typename _Tp4>
+    struct traits<std::unordered_set<_Tp1, _Tp2, _Tp3, _Tp4>>
+    : public traits_base
+    {
+      typedef std::true_type	is_container;
+      typedef std::true_type	is_allocator_aware;
+      typedef std::true_type	is_unordered;
+
+      typedef std::true_type	has_erase;
+      typedef std::true_type	has_insert;
+    };
+} // namespace __gnu_test
+
+#endif
diff --git a/libstdc++-v3/testsuite/util/testsuite_containers.h b/libstdc++-v3/testsuite/util/testsuite_containers.h
new file mode 100644
index 000000000..24133cdc5
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_containers.h
@@ -0,0 +1,229 @@
+// -*- C++ -*-
+
+// Copyright (C) 2009, 2010 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#ifndef _GLIBCXX_TESTSUITE_CONTAINERS_H
+#define _GLIBCXX_TESTSUITE_CONTAINERS_H
+
+#include <cassert>
+#include <testsuite_container_traits.h>
+
+// Container requirement testing.
+namespace __gnu_test
+{
+  // Compile-time typedef testing.
+  template<typename _Tp, bool _Bt = traits<_Tp>::is_container::value>
+    struct basic_types
+    {
+      // Base container requirements (table 80)
+      typedef _Tp 					test_type;
+      typedef typename test_type::value_type 		value_type;
+      typedef typename test_type::pointer 		pointer;
+      typedef typename test_type::const_pointer 	const_pointer;
+      typedef typename test_type::reference 		reference;
+      typedef typename test_type::const_reference 	const_reference;
+      typedef typename test_type::iterator 		iterator;
+      typedef typename test_type::const_iterator 	const_iterator;
+      typedef typename test_type::size_type 		size_type;
+      typedef typename test_type::difference_type 	difference_type;
+    };
+
+  // Conditional typedef testing, positive.
+  template<typename _Tp, bool _Bt = traits<_Tp>::is_reversible::value>
+    struct reversible_types
+    {
+      // Reversible container requirements (table 81)
+      typedef _Tp 					 test_type;
+      typedef typename test_type::reverse_iterator 	 reverse_iterator;
+      typedef typename test_type::const_reverse_iterator const_reverse_iterator;
+    };
+
+  template<typename _Tp, bool _Bt = traits<_Tp>::is_allocator_aware::value>
+    struct allocator_aware_types
+    {
+      // Allocator-aware requirements (table 82)
+      typedef _Tp 					 test_type;
+      typedef typename test_type::allocator_type      	 allocator_type;
+    };
+
+  template<typename _Tp, bool _Bt = traits<_Tp>::is_associative::value>
+    struct associative_types
+    {
+      // Associative container requirements (table 85)
+      typedef _Tp 					 test_type;
+      typedef typename test_type::key_type		 key_type;
+      typedef typename test_type::key_compare		 key_compare;
+      typedef typename test_type::value_compare		 value_compare;
+    };
+
+  template<typename _Tp, bool = traits<_Tp>::is_unordered::value>
+    struct unordered_types
+    {
+      // Unordered associative container requirements (table 87)
+      typedef _Tp 					 test_type;
+      typedef typename test_type::key_type		 key_type;
+      typedef typename test_type::hasher		 hasher;
+      typedef typename test_type::key_equal		 key_equal;
+      typedef typename test_type::local_iterator	 local_iterator;
+      typedef typename test_type::const_local_iterator	 const_local_iterator;
+    };
+
+  template<typename _Tp, bool _Bt = traits<_Tp>::is_mapped::value>
+    struct mapped_types
+    {
+      typedef _Tp 					 test_type;
+      typedef typename test_type::mapped_type	   	 mapped_type;
+    };
+
+  template<typename _Tp, bool = traits<_Tp>::is_adaptor::value>
+    struct adaptor_types
+    {
+      // Container adaptor requirements.
+      typedef _Tp 					test_type;
+      typedef typename test_type::value_type 		value_type;
+      typedef typename test_type::reference 		reference;
+      typedef typename test_type::const_reference 	const_reference;
+      typedef typename test_type::size_type 		size_type;
+      typedef typename test_type::container_type 	container_type;
+    };
+
+  // Conditional typedef testing, negative.
+  template<typename _Tp>
+    struct basic_types<_Tp, false> { };
+
+  template<typename _Tp>
+    struct adaptor_types<_Tp, false> { };
+
+  template<typename _Tp>
+    struct reversible_types<_Tp, false> { };
+
+  template<typename _Tp>
+    struct allocator_aware_types<_Tp, false> { };
+
+  template<typename _Tp>
+    struct associative_types<_Tp, false> { };
+
+  template<typename _Tp>
+    struct unordered_types<_Tp, false> { };
+
+  template<typename _Tp>
+    struct mapped_types<_Tp, false> { };
+
+  // Primary template.
+  template<typename _Tp>
+    struct types
+    : basic_types<_Tp>, adaptor_types<_Tp>, reversible_types<_Tp>,
+      allocator_aware_types<_Tp>, associative_types<_Tp>,
+      unordered_types<_Tp>, mapped_types<_Tp>
+    { };
+
+
+  // Run-time test for constant_iterator requirements.
+  template<typename _Tp, bool = traits<_Tp>::is_allocator_aware::value>
+    struct populate
+    {
+      populate(_Tp& container)
+      {
+	// Avoid uninitialized warnings, requires DefaultContructible.
+	typedef typename _Tp::value_type value_type;
+	container.insert(container.begin(), value_type());
+	container.insert(container.begin(), value_type());
+      }
+  };
+
+  template<typename _Tp>
+    struct populate<_Tp, false>
+    {
+      populate(_Tp& container) { }
+    };
+
+  template<typename _Tp, bool = traits<_Tp>::is_reversible::value>
+    struct reverse_members
+    {
+      reverse_members(_Tp& container)
+      {
+	assert( container.crbegin() == container.rbegin() );
+	assert( container.crend() == container.rend() );
+	assert( container.crbegin() != container.crend() );
+      }
+    };
+
+  template<typename _Tp>
+    struct reverse_members<_Tp, false>
+    {
+      reverse_members(_Tp& container) { }
+    };
+
+  // DR 691.
+  template<typename _Tp, bool = traits<_Tp>::is_unordered::value>
+    struct forward_members_unordered
+    {
+      forward_members_unordered(typename _Tp::value_type& v)
+      {
+	typedef _Tp					test_type;
+	test_type container;
+	container.insert(v);
+	assert( container.cbegin(0) == container.begin(0) );
+	assert( container.cend(0) == container.end(0) );
+	const typename test_type::size_type bn = container.bucket(1);
+	assert( container.cbegin(bn) != container.cend(bn) );
+      }
+    };
+
+  template<typename _Tp>
+    struct forward_members_unordered<_Tp, false>
+    {
+      forward_members_unordered(_Tp& container) { }
+    };
+
+  template<typename _Tp>
+    struct citerator
+    {
+      typedef _Tp 					test_type;
+      typedef traits<test_type>				traits_type;
+      typedef typename test_type::value_type 		value_type;
+
+      static test_type _S_container;
+
+      // Unconditional.
+      struct forward_members
+      {
+	forward_members()
+	{
+	  assert( _S_container.cbegin() == _S_container.begin() );
+	  assert( _S_container.cend() == _S_container.end() );
+	  assert( _S_container.cbegin() != _S_container.cend() );
+	}
+      };
+
+      // Run test.
+      citerator()
+      {
+	populate<test_type> p(_S_container);
+	forward_members m1;
+	reverse_members<test_type> m2(_S_container);
+      }
+  };
+
+  template<typename _Tp>
+  _Tp citerator<_Tp>::_S_container;
+
+
+} // namespace __gnu_test
+
+#endif
diff --git a/libstdc++-v3/testsuite/util/testsuite_error.h b/libstdc++-v3/testsuite/util/testsuite_error.h
new file mode 100644
index 000000000..c2bfed737
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_error.h
@@ -0,0 +1,59 @@
+// -*- C++ -*-
+// Error handling utils for the C++ library testsuite. 
+//
+// Copyright (C) 2007, 2008, 2009, 2010 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+//
+
+#include <string>
+#include <testsuite_hooks.h>
+
+#ifndef _TESTSUITE_ERROR_H
+#define _TESTSUITE_ERROR_H 1
+
+namespace __gnu_test
+{
+  struct test_category : public std::error_category
+  { 
+    test_category() {}
+
+    virtual const char*
+    name() const 
+    { 
+      const char* s = "__gnu_test::test_category";
+      return s;
+    }
+
+    virtual std::string 
+    message(int) const
+    { return std::string("message to be determined"); }
+  };
+
+  struct test_derived_category : public test_category
+  { 
+    test_derived_category() {}
+
+    virtual const char*
+    name() const 
+    { 
+      const char* s = "__gnu_test::test_derived_category";
+      return s;
+    }
+  };
+
+}
+#endif
diff --git a/libstdc++-v3/testsuite/util/testsuite_greedy_ops.h b/libstdc++-v3/testsuite/util/testsuite_greedy_ops.h
new file mode 100644
index 000000000..8dcbfdb84
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_greedy_ops.h
@@ -0,0 +1,58 @@
+// Copyright (C) 2010 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+namespace greedy_ops
+{
+  struct X
+  { };
+
+  template<typename T>
+  X operator==(T, T)
+  { return X(); }
+
+  template<typename T>
+  X operator!=(T, T)
+  { return X(); }
+
+  template<typename T>
+  X operator<(T, T)
+  { return X(); }
+
+  template<typename T>
+  X operator<=(T, T)
+  { return X(); }
+
+  template<typename T>
+    X operator>(T, T)
+  { return X(); }
+
+  template<typename T>
+  X operator>=(T, T)
+  { return X(); }
+
+  template<typename T>
+  X operator-(T, T)
+  { return X(); }
+  /*
+  template<typename T>
+  T operator+(std::size_t, T)
+  { return T(); }
+  */
+  template<typename T>
+  T operator+(T, std::size_t)
+  { return T(); }
+}
diff --git a/libstdc++-v3/testsuite/util/testsuite_hooks.cc b/libstdc++-v3/testsuite/util/testsuite_hooks.cc
new file mode 100644
index 000000000..1ead34851
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_hooks.cc
@@ -0,0 +1,326 @@
+// -*- C++ -*-
+
+// Utility subroutines for the C++ library testsuite. 
+//
+// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+// 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+//
+
+#include <testsuite_hooks.h>
+
+#ifdef _GLIBCXX_RES_LIMITS
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#endif
+
+#include <list>
+#include <string>
+#include <stdexcept>
+#include <clocale>
+#include <cstdlib>
+#include <locale>
+#include <cxxabi.h>
+
+// If we have <sys/types.h>, <sys/ipc.h>, and <sys/sem.h>, then assume
+// that System V semaphores are available.
+#if defined(_GLIBCXX_HAVE_SYS_TYPES_H)		\
+    && defined(_GLIBCXX_HAVE_SYS_IPC_H)		\
+    && defined(_GLIBCXX_HAVE_SYS_SEM_H)
+#define _GLIBCXX_SYSV_SEM
+#endif
+
+#ifdef _GLIBCXX_SYSV_SEM
+#include <sys/types.h>
+#include <sys/ipc.h>
+#include <sys/sem.h>
+#endif
+
+namespace __gnu_test
+{
+#ifdef _GLIBCXX_RES_LIMITS
+  void 
+  set_memory_limits(float size)
+  {
+    struct rlimit r;
+    // Cater to the absence of rlim_t.
+    __typeof__ (r.rlim_cur) limit = (__typeof__ (r.rlim_cur))(size * 1048576);
+
+    // Heap size, seems to be common.
+#if _GLIBCXX_HAVE_LIMIT_DATA
+    getrlimit(RLIMIT_DATA, &r);
+    r.rlim_cur = limit;
+    setrlimit(RLIMIT_DATA, &r);
+#endif
+
+    // Resident set size.
+#if _GLIBCXX_HAVE_LIMIT_RSS
+    getrlimit(RLIMIT_RSS, &r);
+    r.rlim_cur = limit;
+    setrlimit(RLIMIT_RSS, &r);
+#endif
+
+    // Mapped memory (brk + mmap).
+#if _GLIBCXX_HAVE_LIMIT_VMEM
+    getrlimit(RLIMIT_VMEM, &r);
+    r.rlim_cur = limit;
+    setrlimit(RLIMIT_VMEM, &r);
+#endif
+
+    // Virtual memory.  On x86_64-linux, the default is -z
+    // max-page-size=0x200000 which means up to 2MB of address space
+    // are accounted for PROT_NONE mappings between text and data
+    // segments of each shared library.  There are 4 shared libs
+    // involved in addition to the dynamic linker, maybe 5 if libgomp
+    // is being used as well.  Use at least 20MB address space limit.
+#if defined(__x86_64__) && defined(__linux__)
+    if (limit < 20971520)
+      limit = 20971520;
+#endif
+
+    // On HP-UX 11.23, a trivial C++ program that sets RLIMIT_AS to
+    // anything less than 128MB cannot "malloc" even 1K of memory.
+    // Therefore, we skip RLIMIT_AS on HP-UX.
+#if _GLIBCXX_HAVE_LIMIT_AS && !defined(__hpux__)
+    getrlimit(RLIMIT_AS, &r);
+    r.rlim_cur = limit;
+    setrlimit(RLIMIT_AS, &r);
+#endif
+  }
+
+#else
+  void
+  set_memory_limits(float) { }
+#endif 
+
+#ifdef _GLIBCXX_RES_LIMITS
+  void 
+  set_file_limit(unsigned long size)
+  {
+#if _GLIBCXX_HAVE_LIMIT_FSIZE
+    struct rlimit r;
+    // Cater to the absence of rlim_t.
+    __typeof__ (r.rlim_cur) limit = (__typeof__ (r.rlim_cur))(size);
+
+    getrlimit(RLIMIT_FSIZE, &r);
+    r.rlim_cur = limit;
+    setrlimit(RLIMIT_FSIZE, &r);
+#endif
+  }
+
+#else
+  void
+  set_file_limit(unsigned long) { }
+#endif 
+
+  void 
+  verify_demangle(const char* mangled, const char* wanted)
+  {
+    int status = 0;
+    const char* s = abi::__cxa_demangle(mangled, 0, 0, &status);
+    if (!s)
+      {
+	switch (status)
+	  {
+	  case 0:
+	    s = "error code = 0: success";
+	    break;
+	  case -1:
+	    s = "error code = -1: memory allocation failure";
+	    break;
+	  case -2:
+	    s = "error code = -2: invalid mangled name";
+	    break;
+	  case -3:
+	    s = "error code = -3: invalid arguments";
+	    break;
+	  default:
+	    s = "error code unknown - who knows what happened";
+	  }
+      }
+
+    std::string w(wanted);
+    if (w != s)
+      std::__throw_runtime_error(s);
+  }
+
+  void 
+  run_tests_wrapped_locale(const char* name, const func_callback& l)
+  {
+    using namespace std;
+    
+    // Set the global locale. 
+    locale loc_name = locale(name);
+    locale orig = locale::global(loc_name);
+
+    const char* res = setlocale(LC_ALL, name);
+    if (res)
+      {
+	string preLC_ALL = res;
+	const func_callback::test_type* tests = l.tests();
+	for (int i = 0; i < l.size(); ++i)
+	  (*tests[i])();
+	string postLC_ALL= setlocale(LC_ALL, 0);
+	VERIFY( preLC_ALL == postLC_ALL );
+      }
+    else
+      {
+	string s("LC_ALL for ");
+	s += name;
+	__throw_runtime_error(s.c_str());
+      }
+  }
+  
+  void 
+  run_tests_wrapped_env(const char* name, const char* env,
+			const func_callback& l)
+  {
+    using namespace std;
+    
+#ifdef _GLIBCXX_HAVE_SETENV 
+    // Set the global locale. 
+    locale loc_name = locale(name);
+    locale orig = locale::global(loc_name);
+
+    // Set environment variable env to value in name. 
+    const char* oldENV = getenv(env);
+    if (!setenv(env, name, 1))
+      {
+	const func_callback::test_type* tests = l.tests();
+	for (int i = 0; i < l.size(); ++i)
+	  (*tests[i])();
+	setenv(env, oldENV ? oldENV : "", 1);
+      }
+    else
+      {
+	string s(env);
+	s += string(" to ");
+	s += string(name);
+	__throw_runtime_error(s.c_str());
+      }
+#endif
+  }
+
+  object_counter::size_type  object_counter::count = 0;
+  unsigned int copy_constructor::count_ = 0;
+  unsigned int copy_constructor::throw_on_ = 0;
+  unsigned int assignment_operator::count_ = 0;
+  unsigned int assignment_operator::throw_on_ = 0;
+  unsigned int destructor::_M_count = 0;
+  int copy_tracker::next_id_ = 0;
+
+#ifdef _GLIBCXX_SYSV_SEM
+  // This union is not declared in system headers.  Instead, it must
+  // be defined by user programs.
+  union semun 
+  {
+    int val;
+    struct semid_ds *buf;
+    unsigned short *array;
+  };
+#endif
+
+  semaphore::semaphore() 
+  {
+#ifdef _GLIBCXX_SYSV_SEM
+    // Remeber the PID for the process that created the semaphore set
+    // so that only one process will destroy the set.
+    pid_ = getpid();
+
+    // GLIBC does not define SEM_R and SEM_A.
+#ifndef SEM_R
+#define SEM_R 0400
+#endif
+    
+#ifndef SEM_A
+#define SEM_A 0200
+#endif
+
+    // Get a semaphore set with one semaphore.
+    sem_set_ = semget(IPC_PRIVATE, 1, SEM_R | SEM_A);
+    if (sem_set_ == -1)
+      std::__throw_runtime_error("could not obtain semaphore set");
+
+    // Initialize the semaphore.
+    union semun val;
+    val.val = 0;
+    if (semctl(sem_set_, 0, SETVAL, val) == -1)
+      std::__throw_runtime_error("could not initialize semaphore");
+#else
+    // There are no semaphores on this system.  We have no way to mark
+    // a test as "unsupported" at runtime, so we just exit, pretending
+    // that the test passed.
+    exit(0);
+#endif
+  }
+
+  semaphore::~semaphore() 
+  {
+#ifdef _GLIBCXX_SYSV_SEM
+    union semun val;
+    val.val = 0; // Avoid uninitialized variable warning.
+    // Destroy the semaphore set only in the process that created it. 
+    if (pid_ == getpid())
+      semctl(sem_set_, 0, IPC_RMID, val);
+#endif
+  }
+
+  void
+  semaphore::signal() 
+  {
+#ifdef _GLIBCXX_SYSV_SEM
+    struct sembuf op[1] = 
+      {
+	{ 0, 1, 0 }
+      };
+    if (semop(sem_set_, op, 1) == -1)
+      std::__throw_runtime_error("could not signal semaphore");
+#endif
+  }
+
+  void
+  semaphore::wait() 
+  {
+#ifdef _GLIBCXX_SYSV_SEM
+    struct sembuf op[1] = 
+      {
+	{ 0, -1, SEM_UNDO }
+      };
+    if (semop(sem_set_, op, 1) == -1)
+      std::__throw_runtime_error("could not wait for semaphore");
+#endif    
+  }
+
+  // For use in 22_locale/time_get and time_put.
+  std::tm
+  test_tm(int sec, int min, int hour, int mday, int mon,
+	  int year, int wday, int yday, int isdst)
+  {
+    static std::tm tmp;
+    tmp.tm_sec = sec;
+    tmp.tm_min = min;
+    tmp.tm_hour = hour;
+    tmp.tm_mday = mday;
+    tmp.tm_mon = mon;
+    tmp.tm_year = year;
+    tmp.tm_wday = wday;
+    tmp.tm_yday = yday;
+    tmp.tm_isdst = isdst;
+    return tmp;
+  }
+} // namespace __gnu_test
diff --git a/libstdc++-v3/testsuite/util/testsuite_hooks.h b/libstdc++-v3/testsuite/util/testsuite_hooks.h
new file mode 100644
index 000000000..fe41b1cb3
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_hooks.h
@@ -0,0 +1,345 @@
+// -*- C++ -*-
+// Utility subroutines for the C++ library testsuite. 
+//
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
+// 2009, 2010
+// 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+//
+
+// This file provides the following:
+//
+// 1)  VERIFY(), via _GLIBCXX_ASSERT, from Brent Verner <brent@rcfile.org>.
+//   This file is included in the various testsuite programs to provide
+//   #define(able) assert() behavior for debugging/testing. It may be
+//   a suitable location for other furry woodland creatures as well.
+//
+// 2)  set_memory_limits()
+//   set_memory_limits() uses setrlimit() to restrict dynamic memory
+//   allocation.  We provide a default memory limit if none is passed by the
+//   calling application.  The argument to set_memory_limits() is the
+//   limit in megabytes (a floating-point number).  If _GLIBCXX_RES_LIMITS is
+//   not #defined before including this header, then no limiting is attempted.
+//
+// 3)  object_counter
+//   This is a POD with a static data member, object_counter::count,
+//   which starts at zero, increments on instance construction, and decrements
+//   on instance destruction.  "assert_count(n)" can be called to VERIFY()
+//   that the count equals N.
+//
+// 4)  copy_tracker, from Stephen M. Webb <stephen@bregmasoft.com>.
+//   A class with nontrivial ctor/dtor that provides the ability to track the
+//   number of copy ctors and dtors, and will throw on demand during copy.
+
+#ifndef _GLIBCXX_TESTSUITE_HOOKS_H
+#define _GLIBCXX_TESTSUITE_HOOKS_H
+
+#include <bits/c++config.h>
+#include <bits/functexcept.h>
+#include <ctime>
+
+#ifdef _GLIBCXX_HAVE_SYS_STAT_H
+#include <sys/stat.h>
+#endif
+
+#ifdef _GLIBCXX_ASSERT
+# include <cassert>
+# define VERIFY(fn) assert(fn)
+#else
+# define VERIFY(fn) test &= bool(fn)
+#endif
+
+#ifdef _GLIBCXX_HAVE_UNISTD_H
+# include <unistd.h>
+#else
+# define unlink(x)
+#endif
+
+namespace __gnu_test
+{
+  // All macros are defined in GLIBCXX_CONFIGURE_TESTSUITE and imported
+  // from c++config.h
+
+  // Set memory limits if possible, if not set to 0.
+#ifndef _GLIBCXX_RES_LIMITS
+#  define MEMLIMIT_MB 0
+#else
+# ifndef MEMLIMIT_MB
+#  define MEMLIMIT_MB 16.0
+# endif
+#endif
+  extern void
+  set_memory_limits(float __size = MEMLIMIT_MB);
+
+  extern void
+  set_file_limit(unsigned long __size);
+
+  // Check mangled name demangles (using __cxa_demangle) as expected.
+  void
+  verify_demangle(const char* mangled, const char* wanted);
+
+  // Simple callback structure for variable numbers of tests (all with
+  // same signature).  Assume all unit tests are of the signature
+  // void test01(); 
+  class func_callback
+  {
+  public:
+    typedef void (*test_type) (void);
+
+  private:
+    int		_M_size;
+    test_type	_M_tests[15];
+
+    func_callback&
+    operator=(const func_callback&);
+
+    func_callback(const func_callback&);
+
+  public:
+    func_callback(): _M_size(0) { }
+
+    int
+    size() const { return _M_size; }
+
+    const test_type*
+    tests() const { return _M_tests; }
+
+    void
+    push_back(test_type test)
+    {
+      _M_tests[_M_size] = test;
+      ++_M_size;
+    }
+  };
+
+
+  // Run select unit tests after setting global locale.
+  void 
+  run_tests_wrapped_locale(const char*, const func_callback&);
+
+  // Run select unit tests after setting environment variables.
+  void 
+  run_tests_wrapped_env(const char*, const char*, const func_callback&);
+
+  // Counting.
+  struct object_counter
+  {
+    // Specifically and glaringly-obviously marked 'signed' so that
+    // when COUNT mistakenly goes negative, we can track the patterns
+    // of deletions more easily.
+    typedef  signed int     size_type;
+    static size_type   count;
+    object_counter() { ++count; }
+    object_counter (const object_counter&) { ++count; }
+    ~object_counter() { --count; }
+  };
+  
+#define assert_count(n)   VERIFY(__gnu_test::object_counter::count == n)
+  
+  // A (static) class for counting copy constructors and possibly throwing an
+  // exception on a desired count.
+  class copy_constructor
+  {
+  public:
+    static unsigned int
+    count() { return count_; }
+    
+    static void
+    mark_call()
+    {
+      count_++;
+      if (count_ == throw_on_)
+	std::__throw_runtime_error("copy_constructor::mark_call");
+    }
+      
+    static void
+    reset()
+    {
+      count_ = 0;
+      throw_on_ = 0;
+    }
+      
+    static void
+    throw_on(unsigned int count) { throw_on_ = count; }
+
+  private:
+    static unsigned int count_;
+    static unsigned int throw_on_;
+  };
+  
+  // A (static) class for counting assignment operator calls and
+  // possibly throwing an exception on a desired count.
+  class assignment_operator
+  {
+  public:
+    static unsigned int
+    count() { return count_; }
+    
+    static void
+    mark_call()
+    {
+      count_++;
+      if (count_ == throw_on_)
+	std::__throw_runtime_error("assignment_operator::mark_call");
+    }
+
+    static void
+    reset()
+    {
+      count_ = 0;
+      throw_on_ = 0;
+    }
+
+    static void
+    throw_on(unsigned int count) { throw_on_ = count; }
+
+  private:
+    static unsigned int count_;
+    static unsigned int throw_on_;
+  };
+  
+  // A (static) class for tracking calls to an object's destructor.
+  class destructor
+  {
+  public:
+    static unsigned int
+    count() { return _M_count; }
+    
+    static void
+    mark_call() { _M_count++; }
+
+    static void
+    reset() { _M_count = 0; }
+
+  private:
+    static unsigned int _M_count;
+  };
+  
+  // An class of objects that can be used for validating various
+  // behaviours and guarantees of containers and algorithms defined in
+  // the standard library.
+  class copy_tracker
+  {
+  public:
+    // Creates a copy-tracking object with the given ID number.  If
+    // "throw_on_copy" is set, an exception will be thrown if an
+    // attempt is made to copy this object.
+    copy_tracker(int id = next_id_--, bool throw_on_copy = false)
+    : id_(id) , throw_on_copy_(throw_on_copy) { }
+
+    // Copy-constructs the object, marking a call to the copy
+    // constructor and forcing an exception if indicated.
+    copy_tracker(const copy_tracker& rhs)
+    : id_(rhs.id()), throw_on_copy_(rhs.throw_on_copy_)
+    {
+      if (throw_on_copy_)
+	copy_constructor::throw_on(copy_constructor::count() + 1);
+      copy_constructor::mark_call();
+    }
+
+    // Assigns the value of another object to this one, tracking the
+    // number of times this member function has been called and if the
+    // other object is supposed to throw an exception when it is
+    // copied, well, make it so.
+    copy_tracker&
+    operator=(const copy_tracker& rhs)
+    { 
+      id_ = rhs.id();
+      if (rhs.throw_on_copy_)
+        assignment_operator::throw_on(assignment_operator::count() + 1);
+      assignment_operator::mark_call();
+      return *this;
+    }
+
+    ~copy_tracker()
+    { destructor::mark_call(); }
+
+    int
+    id() const { return id_; }
+
+    static void
+    reset()
+    {
+      copy_constructor::reset();
+      assignment_operator::reset();
+      destructor::reset();
+    }
+
+  private:
+    int   id_;
+    const bool  throw_on_copy_;
+    static int next_id_;
+  };
+
+  inline bool
+  operator==(const copy_tracker& lhs, const copy_tracker& rhs)
+  { return lhs.id() == rhs.id(); }
+
+  inline bool
+  operator<(const copy_tracker& lhs, const copy_tracker& rhs)
+  { return lhs.id() < rhs.id(); }
+
+  // Class for checking required type conversions, implicit and
+  // explicit for given library data structures. 
+  template<typename _Container>
+    struct conversion
+    {
+      typedef typename _Container::const_iterator const_iterator;
+      
+      // Implicit conversion iterator to const_iterator.
+      static const_iterator
+      iterator_to_const_iterator()
+      {
+	_Container v;
+	const_iterator it = v.begin();
+	const_iterator end = v.end();
+	return it == end ? v.end() : it;
+      }
+    };
+
+  // A binary semaphore for use across multiple processes.
+  class semaphore 
+  {
+  public:
+    // Creates a binary semaphore.  The semaphore is initially in the
+    // unsignaled state. 
+    semaphore();
+
+    // Destroy the semaphore.
+    ~semaphore();
+
+    // Signal the semaphore.  If there are processes blocked in
+    // "wait", exactly one will be permitted to proceed.
+    void signal();
+
+    // Wait until the semaphore is signaled.
+    void wait();
+
+  private:
+    int sem_set_;
+
+    pid_t pid_;
+  };
+
+  // For use in 22_locale/time_get and time_put.
+  std::tm test_tm(int sec, int min, int hour, int mday, int mon,
+		  int year, int wday, int yday, int isdst);
+
+} // namespace __gnu_test
+
+#endif // _GLIBCXX_TESTSUITE_HOOKS_H
+
diff --git a/libstdc++-v3/testsuite/util/testsuite_io.h b/libstdc++-v3/testsuite/util/testsuite_io.h
new file mode 100644
index 000000000..681448aa5
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_io.h
@@ -0,0 +1,319 @@
+// -*- C++ -*-
+// Testing streambuf/filebuf/stringbuf for the C++ library testsuite.
+//
+// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009, 2010
+// 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+//
+
+#ifndef _GLIBCXX_TESTSUITE_IO_H
+#define _GLIBCXX_TESTSUITE_IO_H
+
+#include <ios>
+
+namespace __gnu_test
+{  
+  // Used to verify the constraints/requirements on get and put areas
+  // as defined in 
+  // 27.5.1 - Stream buffer requirements: get and put areas
+  // 27.8.1.1 - Template class basic_filebuf p 3
+  //   If the file is not open (ios_base::in) -> input seq. cannot be read
+  //   If the file is not open (ios_base::out) -> output seq. cannot be written
+  //   Joint file position
+  // 27.8.1.4 - Overridden virtual functions p9
+  //   If unbuffered, pbase == pptr == NULL
+  // 27.7.1.1 - Basic_stringbuf constructors p 1
+  // 27.8.1.2 - Basic_filebuf constructors p 1
+  //   ... , initializing the base class with basic_streambuf() 27.5.2.1
+  template<typename T>
+    class constraint_buf
+    : public T
+    {
+    public:
+      bool
+      write_position() 
+      { 
+	bool one = this->pptr() != 0; 
+	bool two = this->pptr() < this->epptr();
+	return one && two;
+      }
+      
+      bool
+      read_position()
+      { 
+	bool one = this->gptr() != 0; 
+	bool two = this->gptr() < this->egptr();
+	return one && two;
+      }
+      
+      bool
+      unbuffered() 
+      { 
+	bool one = this->pbase() == 0; 
+	bool two = this->pptr() == 0; 
+	return one && two;
+      }
+  
+      bool
+      check_pointers()
+      {
+	bool one   = this->eback() == 0;
+	bool two   = this->gptr() == 0;
+	bool three = this->egptr() == 0;
+	
+	bool four  = this->pbase() == 0;
+	bool five  = this->pptr() == 0;
+	bool six   = this->epptr() == 0;
+	return one && two && three && four && five && six;
+      }
+    };
+
+  typedef  constraint_buf<std::streambuf>   constraint_streambuf;
+  typedef  constraint_buf<std::filebuf>     constraint_filebuf;
+  typedef  constraint_buf<std::stringbuf>   constraint_stringbuf;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  typedef  constraint_buf<std::wstreambuf>  constraint_wstreambuf;
+  typedef  constraint_buf<std::wfilebuf>    constraint_wfilebuf;
+  typedef  constraint_buf<std::wstringbuf>  constraint_wstringbuf;
+#endif
+
+  // Used to check if basic_streambuf::pubsync() has been called.
+  // This is useful for checking if a function creates [io]stream::sentry
+  // objects, since the sentry constructors call tie()->flush().
+  template<typename T>
+    class sync_buf
+    : public T
+    {
+    private:
+      bool m_sync_called;
+    
+    public:
+      sync_buf()
+      : m_sync_called(false)
+      { }
+      
+      bool sync_called() const
+      { return m_sync_called; }
+
+    protected:
+      int sync()
+      {
+	m_sync_called = true;
+	return 0;
+      }
+    };
+
+  typedef  sync_buf<std::streambuf>   sync_streambuf;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  typedef  sync_buf<std::wstreambuf>  sync_wstreambuf;
+#endif
+
+  // Throws on all overflow and underflow calls.
+  struct underflow_error: std::exception { };
+  struct overflow_error: std::exception { };
+  struct positioning_error: std::exception { };
+
+  template<typename T>
+    struct fail_buf
+    : public T
+    {
+      typedef typename T::char_type   char_type;
+      typedef typename T::int_type    int_type;
+      typedef typename T::off_type    off_type;
+      typedef typename T::pos_type    pos_type;
+
+    private:
+      char_type p[2];
+
+    public:
+      fail_buf()
+      {
+	p[0] = char_type('s');
+	p[1] = char_type();
+	setg(p, p, p + 1); 
+      }
+
+      virtual int_type underflow() 
+      {
+	throw underflow_error();
+	return int_type();
+      }
+      
+      virtual int_type uflow() 
+      {
+	throw underflow_error();
+	return int_type();
+      }
+      
+      virtual int_type
+      overflow(int_type)
+      {
+	throw overflow_error();
+	return int_type();
+      }
+      
+      virtual pos_type 
+      seekoff(off_type, std::ios_base::seekdir, std::ios_base::openmode)
+      { 
+	throw positioning_error();
+	return pos_type(off_type(-1)); 
+      } 
+      
+      virtual pos_type 
+      seekpos(pos_type, std::ios_base::openmode)
+      { 
+	throw positioning_error();
+	return pos_type(off_type(-1)); 
+      } 
+      
+      virtual int 
+      sync() 
+      { 
+	throw positioning_error();
+	return 0; 
+      }
+    };
+
+  typedef  fail_buf<std::streambuf>   fail_streambuf;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  typedef  fail_buf<std::wstreambuf>  fail_wstreambuf;
+#endif
+
+  // Facets that throw an exception for every virtual function.
+  struct facet_error: std::exception { };
+
+  template<typename T>
+    class fail_num_get
+    : public std::num_get<T>
+    {
+      typedef std::ios_base ios_base;
+      typedef typename std::num_get<T>::iter_type iter_type;
+
+    protected:
+      iter_type 
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const
+      { throw facet_error(); return iter_type(); }
+
+      virtual iter_type 
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, long&) const
+      { throw facet_error(); return iter_type(); }
+      
+      virtual iter_type 
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, 
+	     unsigned short&) const
+      { throw facet_error(); return iter_type(); }
+      
+      virtual iter_type 
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, 
+	     unsigned int&) const
+      { throw facet_error(); return iter_type(); }
+      
+      virtual iter_type 
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, 
+	     unsigned long&) const
+      { throw facet_error(); return iter_type(); }
+
+#ifdef _GLIBCXX_USE_LONG_LONG 
+      virtual iter_type 
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, 
+	     long long&) const
+      { throw facet_error(); return iter_type(); }
+      
+      virtual iter_type 
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, 
+	     unsigned long long&) const
+      { throw facet_error(); return iter_type(); }
+#endif
+
+      virtual iter_type 
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, 
+	     float&) const
+      { throw facet_error(); return iter_type(); }
+      
+      virtual iter_type 
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, 
+	     double&) const
+      { throw facet_error(); return iter_type(); }
+      
+      virtual iter_type 
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, 
+	     long double&) const
+      { throw facet_error(); return iter_type(); }
+      
+      virtual iter_type 
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, 
+	     void*&) const
+      { throw facet_error(); return iter_type(); }
+    };
+
+  typedef  fail_num_get<char>     fail_num_get_char;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  typedef  fail_num_get<wchar_t>  fail_num_get_wchar_t;
+#endif
+
+  template<typename T>
+    class fail_num_put
+    : public std::num_put<T>
+    {
+      typedef std::ios_base ios_base;
+      typedef typename std::num_put<T>::iter_type iter_type;
+      typedef typename std::num_put<T>::char_type char_type;
+
+    protected:
+      iter_type 
+      do_put(iter_type, ios_base&, char_type, bool) const
+      { throw facet_error(); return iter_type(0); }
+      
+      virtual iter_type 
+      do_put(iter_type, ios_base&, char_type, long) const
+      { throw facet_error(); return iter_type(0); }
+
+      virtual iter_type 
+      do_put(iter_type, ios_base&, char_type, unsigned long) const
+      { throw facet_error(); return iter_type(0); }
+
+#ifdef _GLIBCXX_USE_LONG_LONG 
+      virtual iter_type 
+      do_put(iter_type, ios_base&, char_type, long long) const
+      { throw facet_error(); return iter_type(0); }
+
+      virtual iter_type 
+      do_put(iter_type, ios_base&, char_type, unsigned long long) const
+      { throw facet_error(); return iter_type(0); }
+#endif
+      
+      virtual iter_type 
+      do_put(iter_type, ios_base&, char_type, double) const
+      { throw facet_error(); return iter_type(0); }
+
+      virtual iter_type 
+      do_put(iter_type, ios_base&, char_type, long double) const
+      { throw facet_error(); return iter_type(0); }
+      
+      virtual iter_type 
+      do_put(iter_type, ios_base&, char_type, const void*) const
+      { throw facet_error(); return iter_type(0); }
+    };
+
+  typedef  fail_num_put<char>     fail_num_put_char;
+#ifdef _GLIBCXX_USE_WCHAR_T
+  typedef  fail_num_put<wchar_t>  fail_num_put_wchar_t;
+#endif
+} // namespace __gnu_test
+
+#endif // _GLIBCXX_TESTSUITE_IO_H
+
diff --git a/libstdc++-v3/testsuite/util/testsuite_iterators.h b/libstdc++-v3/testsuite/util/testsuite_iterators.h
new file mode 100644
index 000000000..d815b6c57
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_iterators.h
@@ -0,0 +1,552 @@
+// -*- C++ -*-
+// Iterator Wrappers for the C++ library testsuite. 
+//
+// Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010
+// 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+//
+
+// This file provides the following:
+//
+// input_iterator_wrapper, output_iterator_wrapper
+// forward_iterator_wrapper, bidirectional_iterator_wrapper and
+// random_access_wrapper, which attempt to exactly perform the requirements
+// of these types of iterators. These are constructed from the class
+// test_container, which is given two pointers to T and an iterator type.
+
+#include <testsuite_hooks.h>
+#include <bits/stl_iterator_base_types.h>
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+#include <bits/move.h>
+#endif
+
+#ifndef _TESTSUITE_ITERATORS
+#define _TESTSUITE_ITERATORS
+
+#ifdef DISABLE_ITERATOR_DEBUG
+#define ITERATOR_VERIFY(x)
+#else
+#define ITERATOR_VERIFY(x) VERIFY(x)
+#endif
+
+namespace __gnu_test
+{
+  /**
+   * @brief Simple container for holding two pointers.
+   *
+   * Note that input_iterator_wrapper changes first to denote
+   * how the valid range of == , ++, etc. change as the iterators are used.
+   */
+  template<typename T>
+    struct BoundsContainer
+    {
+      T* first;
+      T* last;
+      BoundsContainer(T* _first, T* _last) : first(_first), last(_last)
+      { }
+    };
+
+  // Simple container for holding state of a set of output iterators.
+  template<typename T>
+    struct OutputContainer : public BoundsContainer<T>
+    {
+      T* incrementedto;
+      bool* writtento;
+      OutputContainer(T* _first, T* _last)
+      : BoundsContainer<T>(_first, _last), incrementedto(_first)
+      {
+	writtento = new bool[this->last - this->first];
+	for(int i = 0; i < this->last - this->first; i++)
+	  writtento[i] = false;
+      }
+
+      ~OutputContainer()
+      { delete[] writtento; }
+    };
+
+  // Produced by output_iterator to allow limited writing to pointer
+  template<class T>
+    class WritableObject
+    {
+      T* ptr;
+
+    public:
+      OutputContainer<T>* SharedInfo;
+      WritableObject(T* ptr_in,OutputContainer<T>* SharedInfo_in):
+	ptr(ptr_in), SharedInfo(SharedInfo_in)
+      { }
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+      template<class U>
+      void
+      operator=(U&& new_val)
+      {
+	ITERATOR_VERIFY(SharedInfo->writtento[ptr - SharedInfo->first] == 0);
+	SharedInfo->writtento[ptr - SharedInfo->first] = 1;
+	*ptr = std::forward<U>(new_val);
+      }
+#else
+      template<class U>
+      void
+      operator=(const U& new_val)
+      {
+	ITERATOR_VERIFY(SharedInfo->writtento[ptr - SharedInfo->first] == 0);
+	SharedInfo->writtento[ptr - SharedInfo->first] = 1;
+	*ptr = new_val;
+      }
+#endif
+    };
+
+  /**
+   * @brief output_iterator wrapper for pointer
+   * 
+   * This class takes a pointer and wraps it to provide exactly
+   * the requirements of a output_iterator. It should not be
+   * instansiated directly, but generated from a test_container
+   */
+  template<class T>
+  struct output_iterator_wrapper
+  : public std::iterator<std::output_iterator_tag, T, std::ptrdiff_t, T*, T&>
+  {
+    typedef OutputContainer<T> ContainerType;
+    T* ptr;
+    ContainerType* SharedInfo;
+
+    output_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in)
+    : ptr(_ptr), SharedInfo(SharedInfo_in)
+    {
+      ITERATOR_VERIFY(ptr >= SharedInfo->first && ptr <= SharedInfo->last);
+    }
+    
+    output_iterator_wrapper(const output_iterator_wrapper& in)
+    : ptr(in.ptr), SharedInfo(in.SharedInfo)
+    { }
+
+    WritableObject<T>
+    operator*() const
+    {
+      ITERATOR_VERIFY(ptr < SharedInfo->last);
+      ITERATOR_VERIFY(SharedInfo->writtento[ptr - SharedInfo->first] == false);
+      return WritableObject<T>(ptr, SharedInfo);
+    }
+    
+    output_iterator_wrapper&
+    operator=(const output_iterator_wrapper& in) 
+    {
+      ptr = in.ptr;
+      SharedInfo = in.SharedInfo;
+      return *this;
+    }
+
+    output_iterator_wrapper&
+    operator++()
+    {
+      ITERATOR_VERIFY(SharedInfo && ptr < SharedInfo->last);
+      ITERATOR_VERIFY(ptr>=SharedInfo->incrementedto);
+      ptr++;
+      SharedInfo->incrementedto=ptr;
+      return *this;
+    }
+
+    output_iterator_wrapper
+    operator++(int)
+    {
+      output_iterator_wrapper<T> tmp = *this;
+      ++*this;
+      return tmp;
+    }
+
+  };
+
+  /**
+   * @brief input_iterator wrapper for pointer
+   * 
+   * This class takes a pointer and wraps it to provide exactly
+   * the requirements of a input_iterator. It should not be
+   * instansiated directly, but generated from a test_container
+   */
+  template<class T>
+  class input_iterator_wrapper
+  : public std::iterator<std::input_iterator_tag, T, std::ptrdiff_t, T*, T&>
+  {
+  protected:
+    input_iterator_wrapper()
+    { }
+
+  public:
+    typedef BoundsContainer<T> ContainerType;
+    T* ptr;
+    ContainerType* SharedInfo;
+
+    input_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in)
+    : ptr(_ptr), SharedInfo(SharedInfo_in)
+    { ITERATOR_VERIFY(ptr >= SharedInfo->first && ptr <= SharedInfo->last); }
+    
+    input_iterator_wrapper(const input_iterator_wrapper& in)
+    : ptr(in.ptr), SharedInfo(in.SharedInfo)
+    { }
+
+    bool
+    operator==(const input_iterator_wrapper& in) const
+    {
+      ITERATOR_VERIFY(SharedInfo && SharedInfo == in.SharedInfo);
+      ITERATOR_VERIFY(ptr>=SharedInfo->first && in.ptr>=SharedInfo->first);
+      return ptr == in.ptr;
+    }
+
+    bool
+    operator!=(const input_iterator_wrapper& in) const
+    {
+      return !(*this == in);
+    }
+
+    T&
+    operator*() const
+    {
+      ITERATOR_VERIFY(SharedInfo && ptr < SharedInfo->last);
+      ITERATOR_VERIFY(ptr >= SharedInfo->first);
+      return *ptr;
+    }
+
+    T*
+    operator->() const
+    {
+      return &**this;
+    }
+
+    input_iterator_wrapper&
+    operator=(const input_iterator_wrapper& in)
+    {
+      ptr = in.ptr;
+      SharedInfo = in.SharedInfo;
+      return *this;
+    }
+
+    input_iterator_wrapper&
+    operator++()
+    {
+      ITERATOR_VERIFY(SharedInfo && ptr < SharedInfo->last);
+      ITERATOR_VERIFY(ptr>=SharedInfo->first);
+      ptr++;
+      SharedInfo->first=ptr;
+      return *this;
+    }
+
+    void
+    operator++(int)
+    {
+      ++*this;
+    }
+  };
+
+
+  /**
+   * @brief forward_iterator wrapper for pointer
+   * 
+   * This class takes a pointer and wraps it to provide exactly
+   * the requirements of a forward_iterator. It should not be
+   * instansiated directly, but generated from a test_container
+   */
+  template<class T>
+  struct forward_iterator_wrapper : public input_iterator_wrapper<T>
+  {
+    typedef BoundsContainer<T> ContainerType;
+    typedef std::forward_iterator_tag iterator_category;
+    forward_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in)
+    : input_iterator_wrapper<T>(_ptr, SharedInfo_in)
+    { }
+    
+    forward_iterator_wrapper(const forward_iterator_wrapper& in)
+    : input_iterator_wrapper<T>(in)
+    { }
+
+    forward_iterator_wrapper()
+    {
+      this->ptr = 0;
+      this->SharedInfo = 0;
+    }
+
+    T&
+    operator*() const
+    {
+      ITERATOR_VERIFY(this->SharedInfo && this->ptr < this->SharedInfo->last);
+      return *(this->ptr);
+    }
+
+    T*
+    operator->() const
+    { return &**this; }
+
+    forward_iterator_wrapper&
+    operator++()
+    {
+      ITERATOR_VERIFY(this->SharedInfo && this->ptr < this->SharedInfo->last);
+      this->ptr++;
+      return *this;
+    }
+
+    forward_iterator_wrapper
+    operator++(int)
+    {
+      forward_iterator_wrapper<T> tmp = *this;
+      ++*this;
+      return tmp;
+    }
+   };
+
+  /**
+   * @brief bidirectional_iterator wrapper for pointer
+   * 
+   * This class takes a pointer and wraps it to provide exactly
+   * the requirements of a forward_iterator. It should not be
+   * instansiated directly, but generated from a test_container
+   */
+  template<class T>
+  struct bidirectional_iterator_wrapper : public forward_iterator_wrapper<T>
+  {
+    typedef BoundsContainer<T> ContainerType;
+    typedef std::bidirectional_iterator_tag iterator_category;
+    bidirectional_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in)
+    : forward_iterator_wrapper<T>(_ptr, SharedInfo_in)
+    { }
+
+    bidirectional_iterator_wrapper(const bidirectional_iterator_wrapper& in)
+    : forward_iterator_wrapper<T>(in)
+    { }
+
+    bidirectional_iterator_wrapper(): forward_iterator_wrapper<T>()
+    { }
+
+    bidirectional_iterator_wrapper&
+    operator=(const bidirectional_iterator_wrapper& in)
+    {
+      this->ptr = in.ptr;
+      this->SharedInfo = in.SharedInfo;
+      return *this;
+    }
+   
+    bidirectional_iterator_wrapper&
+    operator++()
+    {
+      ITERATOR_VERIFY(this->SharedInfo && this->ptr < this->SharedInfo->last);
+      this->ptr++;
+      return *this;
+    }
+
+    bidirectional_iterator_wrapper
+    operator++(int)
+    {
+      bidirectional_iterator_wrapper<T> tmp = *this;
+      ++*this;
+      return tmp;
+    }
+
+    bidirectional_iterator_wrapper& 
+    operator--()
+    {
+      ITERATOR_VERIFY(this->SharedInfo && this->ptr > this->SharedInfo->first);
+      this->ptr--;
+      return *this;
+    }
+
+    bidirectional_iterator_wrapper
+    operator--(int)
+    { 
+      bidirectional_iterator_wrapper<T> tmp = *this;
+      --*this;
+      return tmp;
+    }
+   };
+
+  /**
+   * @brief random_access_iterator wrapper for pointer
+   * 
+   * This class takes a pointer and wraps it to provide exactly
+   * the requirements of a forward_iterator. It should not be
+   * instansiated directly, but generated from a test_container
+   */
+  template<class T>
+  struct random_access_iterator_wrapper 
+  : public bidirectional_iterator_wrapper<T>
+  {
+    typedef BoundsContainer<T> ContainerType;
+    typedef std::random_access_iterator_tag iterator_category;
+    random_access_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in)
+    : bidirectional_iterator_wrapper<T>(_ptr, SharedInfo_in)
+    { }
+
+    random_access_iterator_wrapper(const random_access_iterator_wrapper<T>& in)
+    : bidirectional_iterator_wrapper<T>(in)
+    { }
+
+    random_access_iterator_wrapper():bidirectional_iterator_wrapper<T>()
+    { }
+
+    random_access_iterator_wrapper&
+    operator=(const random_access_iterator_wrapper& in)
+    {
+      this->ptr = in.ptr;
+      this->SharedInfo = in.SharedInfo;
+      return *this;
+    }
+
+    random_access_iterator_wrapper&
+    operator++()
+    {
+      ITERATOR_VERIFY(this->SharedInfo && this->ptr < this->SharedInfo->last);
+      this->ptr++;
+      return *this;
+    }
+
+    random_access_iterator_wrapper
+    operator++(int)
+    {
+      random_access_iterator_wrapper<T> tmp = *this;
+      ++*this;
+      return tmp;
+    }
+
+    random_access_iterator_wrapper&
+    operator--()
+    {
+      ITERATOR_VERIFY(this->SharedInfo && this->ptr > this->SharedInfo->first);
+      this->ptr--;
+      return *this;
+    }
+
+    random_access_iterator_wrapper
+    operator--(int)
+    {
+      random_access_iterator_wrapper<T> tmp = *this;
+      --*this;
+      return tmp;
+    }
+
+    random_access_iterator_wrapper&
+    operator+=(std::ptrdiff_t n)
+    {
+      if(n > 0)
+	{
+	  ITERATOR_VERIFY(n <= this->SharedInfo->last - this->ptr);
+	  this->ptr += n;
+	}
+      else
+	{
+	  ITERATOR_VERIFY(n <= this->ptr - this->SharedInfo->first);
+	  this->ptr += n;
+	}
+      return *this;
+    }
+
+    random_access_iterator_wrapper&
+    operator-=(std::ptrdiff_t n)
+    { return *this += -n; }
+
+    random_access_iterator_wrapper
+    operator-(std::ptrdiff_t n) const
+    {
+      random_access_iterator_wrapper<T> tmp = *this;
+      return tmp -= n;
+    }
+
+    std::ptrdiff_t
+    operator-(const random_access_iterator_wrapper<T>& in) const
+    {
+      ITERATOR_VERIFY(this->SharedInfo == in.SharedInfo);
+      return this->ptr - in.ptr;
+    }
+
+    T&
+    operator[](std::ptrdiff_t n) const
+    { return *(*this + n); }
+
+    bool
+    operator<(const random_access_iterator_wrapper<T>& in) const
+    {
+      ITERATOR_VERIFY(this->SharedInfo == in.SharedInfo);
+      return this->ptr < in.ptr;
+    }
+
+    bool
+    operator>(const random_access_iterator_wrapper<T>& in) const
+    {
+      return in < *this;
+    }
+
+    bool
+    operator>=(const random_access_iterator_wrapper<T>& in) const
+    {
+      return !(*this < in);
+    }
+
+    bool 
+    operator<=(const random_access_iterator_wrapper<T>& in) const
+    {
+      return !(*this > in);
+    }
+   };
+
+  template<typename T>
+    random_access_iterator_wrapper<T>
+    operator+(random_access_iterator_wrapper<T> it, std::ptrdiff_t n)
+    { return it += n; }
+
+  template<typename T>
+    random_access_iterator_wrapper<T>
+    operator+(std::ptrdiff_t n, random_access_iterator_wrapper<T> it) 
+    { return it += n; }
+
+
+  /** 
+   * @brief A container-type class for holding iterator wrappers
+   * test_container takes two parameters, a class T and an iterator
+   * wrapper templated by T (for example forward_iterator_wrapper<T>.
+   * It takes two pointers representing a range and presents them as 
+   * a container of iterators.
+   */
+  template <class T, template<class T> class ItType>
+  struct test_container
+  {
+    typename ItType<T>::ContainerType bounds;
+    test_container(T* _first, T* _last):bounds(_first, _last)
+    { }
+
+    ItType<T>
+    it(int pos)
+    {
+      ITERATOR_VERIFY(pos >= 0 && pos <= (bounds.last - bounds.first));
+      return ItType<T>(bounds.first + pos, &bounds);
+    }
+
+    ItType<T>
+    it(T* pos)
+    {
+      ITERATOR_VERIFY(pos >= bounds.first && pos <= bounds.last);
+      return ItType<T>(pos, &bounds);
+    }
+
+    ItType<T>
+    begin()
+    { return it(bounds.first); }
+
+    ItType<T>
+    end()
+    { return it(bounds.last); }
+   };
+}
+#endif
diff --git a/libstdc++-v3/testsuite/util/testsuite_performance.h b/libstdc++-v3/testsuite/util/testsuite_performance.h
new file mode 100644
index 000000000..61efd042d
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_performance.h
@@ -0,0 +1,485 @@
+// -*- C++ -*-
+// Testing performance utilities for the C++ library testsuite.
+//
+// Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010
+// 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+//
+
+#ifndef _GLIBCXX_PERFORMANCE_H
+#define _GLIBCXX_PERFORMANCE_H
+
+#include <sys/times.h>
+#include <sys/resource.h>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+#include <fstream>
+#include <iomanip>
+#include <typeinfo>
+#include <stdexcept>
+#include <sstream>
+#include <cxxabi.h>
+#include <testsuite_common_types.h>
+
+#ifdef __linux__
+#include <malloc.h>
+#elif defined (__FreeBSD__)
+extern "C"
+{
+  struct mallinfo
+  {
+    int uordblks;
+    int hblkhd;
+  };
+
+  struct mallinfo
+  mallinfo(void)
+  {
+    struct mallinfo m = { (((std::size_t) sbrk (0) + 1023) / 1024), 0 };
+    return m;
+  }
+}
+#elif !defined (__hpux__)
+extern "C"
+{
+  struct mallinfo
+  {
+    int uordblks;
+    int hblkhd;
+  };
+
+  struct mallinfo empty = { 0, 0 };
+
+  struct mallinfo
+  mallinfo(void)
+  { return empty; }
+}
+#endif
+
+namespace __gnu_test
+{
+  class time_counter
+  {
+  private:
+    clock_t	elapsed_begin;
+    clock_t	elapsed_end;
+    tms		tms_begin;
+    tms		tms_end;
+
+  public:
+    explicit
+    time_counter() : elapsed_begin(), elapsed_end(), tms_begin(), tms_end()
+    { }
+
+    void 
+    clear() throw()
+    {
+      elapsed_begin = clock_t();
+      elapsed_end = clock_t();
+      tms_begin = tms();
+      tms_end = tms();
+    }
+
+    void
+    start()
+    { 
+      this->clear();
+      elapsed_begin = times(&tms_begin); 
+      const clock_t err = clock_t(-1);
+      if (elapsed_begin == err)
+	std::__throw_runtime_error("time_counter::start");
+    }
+    
+    void
+    stop()
+    { 
+      elapsed_end = times(&tms_end); 
+      const clock_t err = clock_t(-1);
+      if (elapsed_end == err)
+	std::__throw_runtime_error("time_counter::stop");
+    }
+
+    std::size_t
+    real_time() const
+    { return elapsed_end - elapsed_begin; }
+
+    std::size_t
+    user_time() const
+    { return tms_end.tms_utime - tms_begin.tms_utime; }
+
+    std::size_t
+    system_time() const
+    { return tms_end.tms_stime - tms_begin.tms_stime; }
+  };
+
+  class resource_counter
+  {
+    int                 who;
+    rusage	        rusage_begin;
+    rusage	        rusage_end;
+    struct mallinfo  	allocation_begin;
+    struct mallinfo  	allocation_end;
+
+  public:
+    resource_counter(int i = RUSAGE_SELF) : who(i)
+    { this->clear(); }
+    
+    void 
+    clear() throw()
+    { 
+      memset(&rusage_begin, 0, sizeof(rusage_begin)); 
+      memset(&rusage_end, 0, sizeof(rusage_end)); 
+      memset(&allocation_begin, 0, sizeof(allocation_begin)); 
+      memset(&allocation_end, 0, sizeof(allocation_end)); 
+    }
+
+    void
+    start()
+    { 
+      if (getrusage(who, &rusage_begin) != 0 )
+	memset(&rusage_begin, 0, sizeof(rusage_begin));
+      malloc(0); // Needed for some implementations.
+      allocation_begin = mallinfo();
+    }
+    
+    void
+    stop()
+    { 
+      if (getrusage(who, &rusage_end) != 0 )
+	memset(&rusage_end, 0, sizeof(rusage_end));
+      allocation_end = mallinfo();
+    }
+
+    int
+    allocated_memory() const
+    { return ((allocation_end.uordblks - allocation_begin.uordblks)
+	      + (allocation_end.hblkhd - allocation_begin.hblkhd)); }
+    
+    long 
+    hard_page_fault() const
+    { return rusage_end.ru_majflt - rusage_begin.ru_majflt; }
+
+    long 
+    swapped() const
+    { return rusage_end.ru_nswap - rusage_begin.ru_nswap; }
+  };
+
+  inline void
+  start_counters(time_counter& t, resource_counter& r)
+  {
+    t.start();
+    r.start();
+  }
+
+  inline void
+  stop_counters(time_counter& t, resource_counter& r)
+  {
+    t.stop();
+    r.stop();
+  }
+
+  inline void
+  clear_counters(time_counter& t, resource_counter& r)
+  {
+    t.clear();
+    r.clear();
+  }
+
+  void
+  report_performance(const std::string file, const std::string comment, 
+		     const time_counter& t, const resource_counter& r)
+  {
+    const char space = ' ';
+    const char tab = '\t';
+    const char* name = "libstdc++-performance.sum";
+    std::string::const_iterator i = file.begin() + file.find_last_of('/') + 1;
+    std::string testname(i, file.end());
+
+    std::ofstream out(name, std::ios_base::app);
+
+#ifdef __GTHREADS
+    if (__gthread_active_p())
+      testname.append("-thread");
+#endif
+
+    out.setf(std::ios_base::left);
+    out << std::setw(25) << testname << tab;
+    out << std::setw(25) << comment << tab;
+
+    out.setf(std::ios_base::right);
+    out << std::setw(4) << t.real_time() << "r" << space;
+    out << std::setw(4) << t.user_time() << "u" << space;
+    out << std::setw(4) << t.system_time() << "s" << space;
+    out << std::setw(8) << r.allocated_memory() << "mem" << space;
+    out << std::setw(4) << r.hard_page_fault() << "pf" << space;
+    
+    out << std::endl;
+    out.close();
+  }
+
+  void
+  report_header(const std::string file, const std::string header)
+  {
+    const char space = ' ';
+    const char tab = '\t';
+    const char* name = "libstdc++-performance.sum";
+    std::string::const_iterator i = file.begin() + file.find_last_of('/') + 1;
+    std::string testname(i, file.end());
+
+    std::ofstream out(name, std::ios_base::app);
+
+#ifdef __GTHREADS
+    if (__gthread_active_p ())
+      testname.append("-thread");
+#endif
+
+    out.setf(std::ios_base::left);
+    out << std::setw(25) << testname << tab;
+    out << std::setw(40) << header << tab;
+
+    out << std::endl;
+    out.close();
+  }
+} // namespace __gnu_test
+
+
+// Ah, we wish it wasn't so...
+bool first_container = false;
+extern const char* filename;
+
+typedef std::string::size_type (*callback_type) (std::string&);
+
+template<typename Container, int Iter, bool Thread>
+  void
+  write_viz_container(callback_type find_container, const char* filename)
+  {
+    typedef std::string string;
+
+    // Create title.
+    {
+      const char ws(' ');
+      std::ostringstream title;
+	
+      std::string titlename(filename);
+      std::string::size_type n = titlename.find('.');
+      if (n != string::npos)
+	titlename = std::string(titlename.begin(), titlename.begin() + n);
+
+      title << titlename;
+      title << ws;
+      title << Iter;
+      title << ws;
+#if 0
+      title << "thread<";
+      std::boolalpha(title);
+      title << Thread;
+      title << '>';
+#endif
+      
+      titlename += ".title";
+      std::ofstream titlefile(titlename.c_str());
+      if (!titlefile.good())
+	throw std::runtime_error("write_viz_data cannot open titlename");
+      titlefile << title.str() << std::endl;
+    }
+
+    // Create compressed type name.
+    Container obj;
+    int status;
+    std::string type(abi::__cxa_demangle(typeid(obj).name(), 0, 0, &status));
+    
+    // Extract fully-qualified typename.
+    // Assumes "set" or "map" are uniquely determinate.
+    string::iterator beg = type.begin();
+    string::iterator end;
+    string::size_type n = (*find_container)(type);
+
+    // Find start of fully-qualified name.
+    // Assume map, find end.
+    string::size_type nend = type.find('<', n);
+    if (nend != string::npos)
+      end = type.begin() + nend;
+    
+    string compressed_type;
+    compressed_type += '"';
+    compressed_type += string(beg, end);
+    compressed_type += '<';
+#if 0
+    typename Container::key_type v;
+    compressed_type += typeid(v).name();
+#else
+    compressed_type += "int";
+#endif
+    compressed_type += ", A>";
+
+    // XXX
+    if (Thread == true)
+      compressed_type += " thread";
+    compressed_type += '"';
+
+    std::ofstream file(filename, std::ios_base::app);
+    if (!file.good())
+      throw std::runtime_error("write_viz_data cannot open filename");
+    
+    file << compressed_type;
+    first_container = false;
+  }
+
+
+void
+write_viz_data(__gnu_test::time_counter& time, const char* filename)
+{
+  std::ofstream file(filename, std::ios_base::app);  
+  if (!file.good())
+    throw std::runtime_error("write_viz_data cannot open filename");
+  
+  // Print out score in appropriate column.
+  const char tab('\t');
+  int score = time.real_time();
+  file << tab << score;
+}
+
+void
+write_viz_endl(const char* filename)
+{
+  std::ofstream file(filename, std::ios_base::app);
+  if (!file.good())
+    throw std::runtime_error("write_viz_endl cannot open filename");
+  file << std::endl;
+}
+
+
+// Function template, function objects for the tests.
+template<typename TestType>
+  struct value_type : public std::pair<const TestType, TestType>
+  {
+    inline value_type& operator++() 
+    { 
+      ++this->second;
+      return *this; 
+    }
+    
+    inline operator TestType() const { return this->second; }
+  };
+
+template<typename Container, int Iter>
+  void
+  do_loop();
+
+template<typename Container, int Iter>
+  void*
+  do_thread(void* p = 0)
+  {
+    do_loop<Container, Iter>();
+    return p;
+  }
+
+template<typename Container, int Iter, bool Thread>
+  void
+  test_container(const char* filename)
+  {
+    using namespace __gnu_test;
+    time_counter time;
+    resource_counter resource;
+    {
+      start_counters(time, resource);
+      if (!Thread)
+	{
+	  // No threads, so run 4x.
+	  do_loop<Container, Iter * 4>();
+	}
+      else
+	{
+#if defined (_GLIBCXX_GCC_GTHR_POSIX_H) && !defined (NOTHREAD)
+	  pthread_t  t1, t2, t3, t4;
+	  pthread_create(&t1, 0, &do_thread<Container, Iter>, 0);
+	  pthread_create(&t2, 0, &do_thread<Container, Iter>, 0);
+	  pthread_create(&t3, 0, &do_thread<Container, Iter>, 0);
+	  pthread_create(&t4, 0, &do_thread<Container, Iter>, 0);
+	  
+	  pthread_join(t1, 0);
+	  pthread_join(t2, 0);
+	  pthread_join(t3, 0);
+	  pthread_join(t4, 0);
+#endif
+	}
+      stop_counters(time, resource);
+
+      // Detailed text data.
+      Container obj;
+      int status;
+      std::ostringstream comment;
+      comment << "type: " << abi::__cxa_demangle(typeid(obj).name(),
+                                                 0, 0, &status);
+      report_header(filename, comment.str());
+      report_performance("", "", time, resource);
+
+      // Detailed data for visualization.
+      std::string vizfilename(filename);
+      vizfilename += ".dat";
+      write_viz_data(time, vizfilename.c_str());
+    }
+  }
+
+template<bool Thread>
+  struct test_sequence
+  {
+    test_sequence(const char* filename) : _M_filename(filename) { }
+
+    template<class Container>
+      void
+      operator()(Container)
+      {
+	const int i = 20000;
+	test_container<Container, i, Thread>(_M_filename); 
+      }
+
+  private:
+    const char* _M_filename;
+  };
+
+
+inline std::string::size_type
+sequence_find_container(std::string& type)
+{
+  const std::string::size_type npos = std::string::npos;
+  std::string::size_type n1 = type.find("vector");
+  std::string::size_type n2 = type.find("list");
+  std::string::size_type n3 = type.find("deque");
+  std::string::size_type n4 = type.find("string");
+  
+  if (n1 != npos || n2 != npos || n3 != npos || n4 != npos)
+    return std::min(std::min(n1, n2), std::min(n3, n4));
+  else
+    throw std::runtime_error("sequence_find_container not found");
+}
+
+inline std::string::size_type
+associative_find_container(std::string& type)
+{
+  using std::string;
+  string::size_type n1 = type.find("map");
+  string::size_type n2 = type.find("set");
+  if (n1 != string::npos || n2 != string::npos)
+    return std::min(n1, n2);
+  else
+    throw std::runtime_error("associative_find_container not found");
+}
+
+#endif // _GLIBCXX_PERFORMANCE_H
+
diff --git a/libstdc++-v3/testsuite/util/testsuite_rng.h b/libstdc++-v3/testsuite/util/testsuite_rng.h
new file mode 100644
index 000000000..73b909e1e
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_rng.h
@@ -0,0 +1,97 @@
+// -*- C++ -*-
+
+// Copyright (C) 2005, 2006, 2008, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+
+// 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 testsuite_rng.h
+ */
+
+#ifndef _GLIBCXX_TESTSUITE_RNG_H
+#define _GLIBCXX_TESTSUITE_RNG_H
+
+#include <ctime>
+#include <climits>
+#include <debug/debug.h>
+#include <tr1/random>
+
+namespace __gnu_pbds
+{
+  namespace test
+  {
+    class twister_rand_gen
+    {
+    public:
+      twister_rand_gen(unsigned int seed = 
+		       static_cast<unsigned int>(std::time(0)))
+      : m_base_generator(seed)
+      {
+	// Do nothing.
+      }
+
+      void
+      init(unsigned int seed)
+      { m_base_generator.seed(seed); }
+
+      static unsigned int
+      get_time_determined_seed()
+      { return(static_cast<unsigned int>(std::time(0))); }
+
+      unsigned long
+      get_unsigned_long(unsigned long min = 0, 
+			unsigned long max = UINT_MAX - 1)
+      {
+	_GLIBCXX_DEBUG_ASSERT(max >= min);
+	const double prob = get_prob();
+	const unsigned long r = (unsigned long)((max - min + 1) * prob) + min;
+	_GLIBCXX_DEBUG_ASSERT(r <= max);
+	return r;
+      }
+
+      double
+      get_prob()
+      {
+	const double min = m_base_generator.min();
+	const double max = m_base_generator.max();
+	const double range = static_cast<const double>(max - min);
+	const double res = static_cast<const double>(m_base_generator() - min);
+	const double ret = res / range;
+	_GLIBCXX_DEBUG_ASSERT(ret >= 0 && ret <= 1);
+	return ret;
+      }
+
+    private:
+      typedef std::tr1::mt19937 base_generator_t;
+
+      base_generator_t m_base_generator;
+    };
+  } // namespace test
+} // namespace __gnu_pbds
+
+#endif // #ifndef _GLIBCXX_TESTSUITE_RNG_H
diff --git a/libstdc++-v3/testsuite/util/testsuite_rvalref.h b/libstdc++-v3/testsuite/util/testsuite_rvalref.h
new file mode 100644
index 000000000..7725e580a
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_rvalref.h
@@ -0,0 +1,267 @@
+// -*- C++ -*-
+// Testing utilities for the rvalue reference.
+//
+// Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+// 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+//
+
+#ifndef _GLIBCXX_TESTSUITE_RVALREF_H
+#define _GLIBCXX_TESTSUITE_RVALREF_H 1
+
+#include <testsuite_hooks.h>
+#include <bits/functional_hash.h>
+
+namespace __gnu_test
+{
+  // This class is designed to test libstdc++'s template-based rvalue
+  // reference support. It should fail at compile-time if there is an
+  // attempt to copy it.
+  struct rvalstruct
+  {
+    int val;
+    bool valid;
+
+    rvalstruct() : val(0), valid(true)
+    { }
+
+    rvalstruct(int inval) : val(inval), valid(true)
+    { }
+
+    rvalstruct&
+    operator=(int newval)
+    { 
+      val = newval;
+      valid = true;
+      return *this;
+    }
+
+    rvalstruct(const rvalstruct&) = delete;
+
+    rvalstruct(rvalstruct&& in)
+    {
+      bool test __attribute__((unused)) = true;
+      VERIFY( in.valid == true );
+      val = in.val;
+      in.valid = false;
+      valid = true;
+    }
+
+    rvalstruct&
+    operator=(const rvalstruct&) = delete;
+
+    rvalstruct&
+    operator=(rvalstruct&& in)
+    {
+      bool test __attribute__((unused)) = true;
+      VERIFY( this != &in );
+      VERIFY( in.valid == true );
+      val = in.val;
+      in.valid = false;
+      valid = true;
+      return *this;
+    }
+  };
+
+  inline bool 
+  operator==(const rvalstruct& lhs, const rvalstruct& rhs)
+  { return lhs.val == rhs.val; }
+
+  inline bool
+  operator<(const rvalstruct& lhs, const rvalstruct& rhs)
+  { return lhs.val < rhs.val; }
+
+  void
+  swap(rvalstruct& lhs, rvalstruct& rhs)
+  {
+    bool test __attribute__((unused)) = true;
+    VERIFY( lhs.valid && rhs.valid );
+    int temp = lhs.val;
+    lhs.val = rhs.val;
+    rhs.val = temp;
+  }
+
+  // This is a moveable class which copies how many times it is copied.
+  // This is mainly of use in the containers, where the an element inserted
+  // into a container has to be copied once to get there, but we want to check
+  // nothing else is copied.
+  struct copycounter
+  {
+    static int copycount;
+    int val;
+    bool valid;
+    
+    copycounter() : val(0), valid(true)
+    { }
+
+    copycounter(int inval) : val(inval), valid(true)
+    { }
+
+    copycounter(const copycounter& in) : val(in.val), valid(true)
+    {
+      bool test __attribute__((unused)) = true;
+      VERIFY( in.valid == true );
+      ++copycount;
+    }
+
+    copycounter(copycounter&& in)
+    {
+      bool test __attribute__((unused)) = true;
+      VERIFY( in.valid == true );
+      val = in.val;
+      in.valid = false;
+      valid = true;
+    }
+    
+    copycounter&
+    operator=(int newval)
+    { 
+      val = newval;
+      valid = true;
+      return *this;
+    }
+
+    bool
+    operator=(const copycounter& in) 
+    {
+      bool test __attribute__((unused)) = true;
+      VERIFY( in.valid == true );
+      ++copycount;
+      val = in.val;
+      valid = true;
+      return true;
+    }
+
+    copycounter&
+    operator=(copycounter&& in)
+    {
+      bool test __attribute__((unused)) = true;
+      VERIFY(in.valid == true);
+      val = in.val;
+      in.valid = false;
+      valid = true;
+      return *this;
+    }
+    
+    ~copycounter()
+    { valid = false; }
+  };
+
+  int copycounter::copycount = 0;
+  
+  inline bool
+  operator==(const copycounter& lhs, const copycounter& rhs)
+  { return lhs.val == rhs.val; }
+
+  inline bool
+  operator<(const copycounter& lhs, const copycounter& rhs)
+  { return lhs.val < rhs.val; }
+
+  inline void
+  swap(copycounter& lhs, copycounter& rhs)
+  {
+    bool test __attribute__((unused)) = true;
+    VERIFY( lhs.valid && rhs.valid );
+    int temp = lhs.val;
+    lhs.val = rhs.val;
+    rhs.val = temp;
+  }
+
+  // In the occasion of libstdc++/48038.
+  struct rvalstruct_compare_by_value
+  {
+    int val;
+    bool ok;
+
+    rvalstruct_compare_by_value(int v)
+    : val(v), ok(true) { }
+
+    rvalstruct_compare_by_value(const rvalstruct_compare_by_value& rh)
+    : val(rh.val), ok(rh.ok)
+    {
+      bool test __attribute__((unused)) = true;
+      VERIFY(rh.ok);
+    }
+
+    rvalstruct_compare_by_value&
+    operator=(const rvalstruct_compare_by_value& rh)
+    {
+      bool test __attribute__((unused)) = true;
+      VERIFY( rh.ok );
+      val = rh.val;
+      ok = rh.ok;
+      return *this;
+    }
+
+    rvalstruct_compare_by_value(rvalstruct_compare_by_value&& rh)
+    : val(rh.val), ok(rh.ok)
+    {
+      bool test __attribute__((unused)) = true;
+      VERIFY( rh.ok );
+      rh.ok = false;
+    }
+
+    rvalstruct_compare_by_value&
+    operator=(rvalstruct_compare_by_value&& rh)
+    {
+      bool test __attribute__((unused)) = true;
+      VERIFY( rh.ok );
+      val = rh.val;
+      ok = rh.ok;
+      rh.ok = false;
+      return *this;
+    }
+  };
+
+  inline bool
+  operator<(rvalstruct_compare_by_value lh,
+	    rvalstruct_compare_by_value rh)
+  {
+    bool test __attribute__((unused)) = true;
+    VERIFY( rh.ok );
+    VERIFY( lh.ok );
+    return lh.val < rh.val;
+  }
+
+  inline bool
+  order(rvalstruct_compare_by_value lh,
+	rvalstruct_compare_by_value rh)
+  {
+    bool test __attribute__((unused)) = true;
+    VERIFY( rh.ok );
+    VERIFY( lh.ok );
+    return lh.val < rh.val;
+  }
+
+} // namespace __gnu_test
+
+namespace std
+{
+  /// std::hash specialization for __gnu_test::rvalstruct.
+  template<>
+    struct hash<__gnu_test::rvalstruct>
+    {
+      typedef size_t                    result_type;
+      typedef __gnu_test::rvalstruct  argument_type;
+
+      size_t
+      operator()(const __gnu_test::rvalstruct& __rvs) const
+      { return __rvs.val; }
+    };
+}
+
+#endif // _GLIBCXX_TESTSUITE_TR1_H
diff --git a/libstdc++-v3/testsuite/util/testsuite_shared.cc b/libstdc++-v3/testsuite/util/testsuite_shared.cc
new file mode 100644
index 000000000..4999da43d
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_shared.cc
@@ -0,0 +1,72 @@
+// Copyright (C) 2004, 2005, 2006, 2007, 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <string>
+#include <stdexcept>
+#include <iostream>
+#include <sstream>
+#include <ext/mt_allocator.h>
+#include <bits/functexcept.h>
+
+// libstdc++/22309
+extern "C" void
+try_allocation()
+{
+  typedef char value_t;
+
+  typedef __gnu_cxx::__mt_alloc<value_t> allocator_t;
+
+  typedef std::char_traits<value_t> traits_t; 
+  typedef std::basic_string<value_t, traits_t, allocator_t> string_t;
+
+  string_t s;
+  s += "west beach, indiana dunes";
+}
+
+// libstdc++/23591
+extern "C" void 
+try_throw_exception()
+{
+  try
+    {
+      std::__throw_bad_exception();
+    }
+  catch (const std::exception& e)
+    { }
+}
+
+extern "C" void 
+try_function_random_fail()
+{
+  long seed = lrand48();
+  if (seed < 2000)
+    seed = 2000;
+
+  {
+    std::ostringstream s;
+    s << "random_throw, seed: " << seed << std::endl;
+    std::cout << s.str();
+  }
+
+  while (--seed > 0)
+    {
+      try_throw_exception();
+    }
+
+  // Randomly throw. See if other threads cleanup.
+  std::__throw_bad_exception();
+}
diff --git a/libstdc++-v3/testsuite/util/testsuite_tr1.h b/libstdc++-v3/testsuite/util/testsuite_tr1.h
new file mode 100644
index 000000000..6a48a309e
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/testsuite_tr1.h
@@ -0,0 +1,288 @@
+// -*- C++ -*-
+// Testing utilities for the tr1 testsuite.
+//
+// Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010
+// 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+//
+
+#ifndef _GLIBCXX_TESTSUITE_TR1_H
+#define _GLIBCXX_TESTSUITE_TR1_H
+
+#include <ext/type_traits.h>
+
+namespace __gnu_test
+{
+  // For tr1/type_traits.
+  template<template<typename> class Category, typename Type>
+    bool
+    test_category(bool value)
+    {
+      bool ret = true;
+      ret &= Category<Type>::value == value;
+      ret &= Category<const Type>::value == value;
+      ret &= Category<volatile Type>::value == value;
+      ret &= Category<const volatile Type>::value == value;
+      ret &= Category<Type>::type::value == value;
+      ret &= Category<const Type>::type::value == value;
+      ret &= Category<volatile Type>::type::value == value;
+      ret &= Category<const volatile Type>::type::value == value;
+      return ret;
+    }
+
+  template<template<typename> class Property, typename Type>
+    bool
+    test_property(typename Property<Type>::value_type value)
+    {
+      bool ret = true;
+      ret &= Property<Type>::value == value;
+      ret &= Property<Type>::type::value == value;
+      return ret;
+    }
+
+  // For testing tr1/type_traits/extent, which has a second template
+  // parameter.
+  template<template<typename, unsigned> class Property,
+	   typename Type, unsigned Uint>
+    bool
+    test_property(typename Property<Type, Uint>::value_type value)
+    {
+      bool ret = true;
+      ret &= Property<Type, Uint>::value == value;
+      ret &= Property<Type, Uint>::type::value == value;
+      return ret;
+    }
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+  template<template<typename...> class Property, typename... Types>
+    bool
+    test_property(typename Property<Types...>::value_type value)
+    {
+      bool ret = true;
+      ret &= Property<Types...>::value == value;
+      ret &= Property<Types...>::type::value == value;
+      return ret;
+    }
+#endif
+
+  template<template<typename, typename> class Relationship,
+	   typename Type1, typename Type2>
+    bool
+    test_relationship(bool value)
+    {
+      bool ret = true;
+      ret &= Relationship<Type1, Type2>::value == value;
+      ret &= Relationship<Type1, Type2>::type::value == value;
+      return ret;
+    }
+
+  // Test types.
+  class ClassType { };
+  typedef const ClassType           cClassType;
+  typedef volatile ClassType        vClassType;
+  typedef const volatile ClassType  cvClassType;
+
+  class DerivedType : public ClassType { };
+
+  enum EnumType { e0 };
+
+  struct ConvType
+  { operator int() const; };
+
+  class AbstractClass
+  {
+    virtual void rotate(int) = 0;
+  };
+
+  class PolymorphicClass
+  {
+    virtual void rotate(int);
+  };
+
+  class DerivedPolymorphic : public PolymorphicClass { };
+
+  class VirtualDestructorClass
+  {
+    virtual ~VirtualDestructorClass();
+  };
+
+  union UnionType { };
+
+  class IncompleteClass;
+
+  struct ExplicitClass
+  {
+    ExplicitClass(double&);
+    explicit ExplicitClass(int&);
+    ExplicitClass(double&, int&, double&);
+  };
+
+  struct NothrowExplicitClass
+  {
+    NothrowExplicitClass(double&) throw();
+    explicit NothrowExplicitClass(int&) throw();
+    NothrowExplicitClass(double&, int&, double&) throw();
+  };
+
+  struct ThrowExplicitClass
+  {
+    ThrowExplicitClass(double&) throw(int);
+    explicit ThrowExplicitClass(int&) throw(int);
+    ThrowExplicitClass(double&, int&, double&) throw(int);
+  };
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+  struct NoexceptExplicitClass
+  {
+    NoexceptExplicitClass(double&) noexcept(true);
+    explicit NoexceptExplicitClass(int&) noexcept(true);
+    NoexceptExplicitClass(double&, int&, double&) noexcept(true);
+  };
+
+  struct ExceptExplicitClass
+  {
+    ExceptExplicitClass(double&) noexcept(false);
+    explicit ExceptExplicitClass(int&) noexcept(false);
+    ExceptExplicitClass(double&, int&, double&) noexcept(false);
+  };
+#endif
+
+  struct NType   // neither trivial nor standard-layout
+  {
+    int i;
+    int j;
+    virtual ~NType();
+  };
+
+  struct TType   // trivial but not standard-layout
+  {
+    int i;
+  private:
+    int j;
+  };
+
+  struct SLType  // standard-layout but not trivial
+  {
+    int i;
+    int j;
+    ~SLType();
+  };
+
+  struct PODType // both trivial and standard-layout
+  {
+    int i;
+    int j;
+  };
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+  struct LType // literal type
+  {
+    int _M_i;
+
+    constexpr LType(int __i) : _M_i(__i) { }
+  };
+
+  struct LTypeDerived : public LType
+  {
+    constexpr LTypeDerived(int __i) : LType(__i) { }
+  };
+
+  struct NLType // not literal type
+  {
+    int _M_i;
+
+    NLType() : _M_i(0) { }
+
+    constexpr NLType(int __i) : _M_i(__i) { }
+
+    NLType(const NLType& __other) : _M_i(__other._M_i) { }
+
+    ~NLType() { _M_i = 0; }
+  };
+#endif
+
+  int truncate_float(float x) { return (int)x; }
+  long truncate_double(double x) { return (long)x; }
+
+  struct do_truncate_float_t
+  {
+    do_truncate_float_t()
+    {
+      ++live_objects;
+    }
+
+    do_truncate_float_t(const do_truncate_float_t&)
+    {
+      ++live_objects;
+    }
+
+    ~do_truncate_float_t()
+    {
+      --live_objects;
+    }
+
+    int operator()(float x) { return (int)x; }
+
+    static int live_objects;
+  };
+
+  int do_truncate_float_t::live_objects = 0;
+
+  struct do_truncate_double_t
+  {
+    do_truncate_double_t()
+    {
+     ++live_objects;
+    }
+
+    do_truncate_double_t(const do_truncate_double_t&)
+    {
+      ++live_objects;
+    }
+
+    ~do_truncate_double_t()
+    {
+      --live_objects;
+    }
+
+    long operator()(double x) { return (long)x; }
+
+    static int live_objects;
+  };
+
+  int do_truncate_double_t::live_objects = 0;
+
+  struct X
+  {
+    int bar;
+
+    int foo()                   { return 1; }
+    int foo_c() const           { return 2; }
+    int foo_v()  volatile       { return 3; }
+    int foo_cv() const volatile { return 4; }
+  };
+
+  // For use in 8_c_compatibility.
+  template<typename R, typename T>
+    typename __gnu_cxx::__enable_if<std::__are_same<R, T>::__value,
+				    bool>::__type
+    check_ret_type(T)
+    { return true; }
+
+} // namespace __gnu_test
+
+#endif // _GLIBCXX_TESTSUITE_TR1_H
diff --git a/libstdc++-v3/testsuite/util/thread/all.h b/libstdc++-v3/testsuite/util/thread/all.h
new file mode 100644
index 000000000..935570ecc
--- /dev/null
+++ b/libstdc++-v3/testsuite/util/thread/all.h
@@ -0,0 +1,62 @@
+// -*- C++ -*-
+// Utilities for testing threads for the C++ library testsuite.
+//
+// Copyright (C) 2009 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 3, 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 COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+//
+
+#ifndef _GLIBCXX_TESTSUITE_THREAD_H
+#define _GLIBCXX_TESTSUITE_THREAD_H
+
+#include <sstream>
+#include <stdexcept>
+#include <type_traits>
+
+// C++0x only.
+namespace __gnu_test
+{  
+  // Assume _Tp::native_handle_type.
+  // Check C++ to native_handle_type characteristics: size and alignment.
+  template<typename _Tp>
+    void
+    compare_type_to_native_type()
+    {
+      typedef _Tp test_type;
+
+      // Remove possible pointer type.
+      typedef typename test_type::native_handle_type native_handle;
+      typedef typename std::remove_pointer<native_handle>::type native_type;
+
+      int st = sizeof(test_type);
+      int snt = sizeof(native_type);      
+      int at = __alignof__(test_type);
+      int ant = __alignof__(native_type);
+      if (st != snt || at != ant)
+	{
+	  std::ostringstream s;
+	  s << std::endl;
+	  s << "size of _Tp: " << st << std::endl;
+	  s << "alignment of _Tp: " << st << std::endl;
+	  s << "size of *(_Tp::native_handle_type): " << snt << std::endl;
+	  s << "alignment of *(_Tp::native_handle_type): " << snt << std::endl;
+	  throw std::runtime_error(s.str());
+	}
+    }
+} // namespace __gnu_test
+
+#endif // _GLIBCXX_TESTSUITE_THREAD_H
+