Change clang format indentation + .editorconfig file

.editorconfig

@@ -0,0 +1,7 @@
+[*]
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+
+[*.?pp]
+indent_size = 2

_clang-format

@@ -11,8 +11,9 @@ BasedOnStyle: LLVM
 
 # Basic settings
 ColumnLimit: 80
-ContinuationIndentWidth: 4
+NamespaceIndentation: All
-IndentWidth: 4
+ContinuationIndentWidth: 2
+IndentWidth: 2
 UseTab: Never
 Language: Cpp
 Standard: Cpp03

include/boost/unordered/detail/fwd.hpp

@@ -43,17 +43,17 @@
 #endif
 
 namespace boost {
-namespace unordered {
+  namespace unordered {
 #if BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT
-using std::piecewise_construct_t;
+    using std::piecewise_construct_t;
-using std::piecewise_construct;
+    using std::piecewise_construct;
 #else
-struct piecewise_construct_t
+    struct piecewise_construct_t
-{
+    {
-};
+    };
-const piecewise_construct_t piecewise_construct = piecewise_construct_t();
+    const piecewise_construct_t piecewise_construct = piecewise_construct_t();
 #endif
-}
+  }
 }
 
 #endif

include/boost/unordered/detail/map.hpp

@@ -7,10 +7,11 @@
 #include <boost/unordered/unordered_map_fwd.hpp>
 
 namespace boost {
-namespace unordered {
+  namespace unordered {
-namespace detail {
+    namespace detail {
-template <typename A, typename K, typename M, typename H, typename P> struct map
+      template <typename A, typename K, typename M, typename H, typename P>
-{
+      struct map
+      {
         typedef boost::unordered::detail::map<A, K, M, H, P> types;
 
         typedef std::pair<K const, M> value_type;
@@ -36,29 +37,30 @@ template <typename A, typename K, typename M, typename H, typename P> struct map
         typedef boost::unordered::iterator_detail::iterator<node> iterator;
         typedef boost::unordered::iterator_detail::c_iterator<node> c_iterator;
         typedef boost::unordered::iterator_detail::l_iterator<node> l_iterator;
-    typedef boost::unordered::iterator_detail::cl_iterator<node> cl_iterator;
+        typedef boost::unordered::iterator_detail::cl_iterator<node>
+          cl_iterator;
 
         typedef boost::unordered::node_handle_map<node, K, M, A> node_type;
         typedef boost::unordered::insert_return_type_map<node, K, M, A>
           insert_return_type;
-};
+      };
 
-template <typename K, typename M, typename H, typename P, typename A>
+      template <typename K, typename M, typename H, typename P, typename A>
-class instantiate_map
+      class instantiate_map
-{
+      {
         typedef boost::unordered_map<K, M, H, P, A> container;
         container x;
         typename container::node_type node_type;
         typename container::insert_return_type insert_return_type;
-};
+      };
 
-template <typename K, typename M, typename H, typename P, typename A>
+      template <typename K, typename M, typename H, typename P, typename A>
-class instantiate_multimap
+      class instantiate_multimap
-{
+      {
         typedef boost::unordered_multimap<K, M, H, P, A> container;
         container x;
         typename container::node_type node_type;
-};
+      };
-}
+    }
-}
+  }
 }

include/boost/unordered/detail/set.hpp

@@ -7,10 +7,10 @@
 #include <boost/unordered/unordered_set_fwd.hpp>
 
 namespace boost {
-namespace unordered {
+  namespace unordered {
-namespace detail {
+    namespace detail {
-template <typename A, typename T, typename H, typename P> struct set
+      template <typename A, typename T, typename H, typename P> struct set
-{
+      {
         typedef boost::unordered::detail::set<A, T, H, P> types;
 
         typedef T value_type;
@@ -36,28 +36,30 @@ template <typename A, typename T, typename H, typename P> struct set
         typedef boost::unordered::iterator_detail::c_iterator<node> iterator;
         typedef boost::unordered::iterator_detail::c_iterator<node> c_iterator;
         typedef boost::unordered::iterator_detail::cl_iterator<node> l_iterator;
-    typedef boost::unordered::iterator_detail::cl_iterator<node> cl_iterator;
+        typedef boost::unordered::iterator_detail::cl_iterator<node>
+          cl_iterator;
 
         typedef boost::unordered::node_handle_set<node, T, A> node_type;
         typedef boost::unordered::insert_return_type_set<node, T, A>
           insert_return_type;
-};
+      };
 
-template <typename T, typename H, typename P, typename A> class instantiate_set
+      template <typename T, typename H, typename P, typename A>
-{
+      class instantiate_set
+      {
         typedef boost::unordered_set<T, H, P, A> container;
         container x;
         typename container::node_type node_type;
         typename container::insert_return_type insert_return_type;
-};
+      };
 
-template <typename T, typename H, typename P, typename A>
+      template <typename T, typename H, typename P, typename A>
-class instantiate_multiset
+      class instantiate_multiset
-{
+      {
         typedef boost::unordered_multiset<T, H, P, A> container;
         container x;
         typename container::node_type node_type;
-};
+      };
-}
+    }
-}
+  }
 }

include/boost/unordered/unordered_map_fwd.hpp

@@ -17,48 +17,48 @@
 #include <memory>
 
 namespace boost {
-namespace unordered {
+  namespace unordered {
-template <class K, class T, class H = boost::hash<K>,
+    template <class K, class T, class H = boost::hash<K>,
       class P = std::equal_to<K>,
       class A = std::allocator<std::pair<const K, T> > >
-class unordered_map;
+    class unordered_map;
 
-template <class K, class T, class H, class P, class A>
+    template <class K, class T, class H, class P, class A>
-inline bool operator==(
+    inline bool operator==(
       unordered_map<K, T, H, P, A> const&, unordered_map<K, T, H, P, A> const&);
-template <class K, class T, class H, class P, class A>
+    template <class K, class T, class H, class P, class A>
-inline bool operator!=(
+    inline bool operator!=(
       unordered_map<K, T, H, P, A> const&, unordered_map<K, T, H, P, A> const&);
-template <class K, class T, class H, class P, class A>
+    template <class K, class T, class H, class P, class A>
-inline void swap(
+    inline void swap(
       unordered_map<K, T, H, P, A>& m1, unordered_map<K, T, H, P, A>& m2)
       BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)));
 
-template <class K, class T, class H = boost::hash<K>,
+    template <class K, class T, class H = boost::hash<K>,
       class P = std::equal_to<K>,
       class A = std::allocator<std::pair<const K, T> > >
-class unordered_multimap;
+    class unordered_multimap;
 
-template <class K, class T, class H, class P, class A>
+    template <class K, class T, class H, class P, class A>
-inline bool operator==(unordered_multimap<K, T, H, P, A> const&,
+    inline bool operator==(unordered_multimap<K, T, H, P, A> const&,
       unordered_multimap<K, T, H, P, A> const&);
-template <class K, class T, class H, class P, class A>
+    template <class K, class T, class H, class P, class A>
-inline bool operator!=(unordered_multimap<K, T, H, P, A> const&,
+    inline bool operator!=(unordered_multimap<K, T, H, P, A> const&,
       unordered_multimap<K, T, H, P, A> const&);
-template <class K, class T, class H, class P, class A>
+    template <class K, class T, class H, class P, class A>
-inline void swap(unordered_multimap<K, T, H, P, A>& m1,
+    inline void swap(unordered_multimap<K, T, H, P, A>& m1,
       unordered_multimap<K, T, H, P, A>& m2)
       BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)));
 
-template <class N, class K, class T, class A> class node_handle_map;
+    template <class N, class K, class T, class A> class node_handle_map;
-template <class N, class K, class T, class A> struct insert_return_type_map;
+    template <class N, class K, class T, class A> struct insert_return_type_map;
-}
+  }
 
-using boost::unordered::unordered_map;
+  using boost::unordered::unordered_map;
-using boost::unordered::unordered_multimap;
+  using boost::unordered::unordered_multimap;
-using boost::unordered::swap;
+  using boost::unordered::swap;
-using boost::unordered::operator==;
+  using boost::unordered::operator==;
-using boost::unordered::operator!=;
+  using boost::unordered::operator!=;
 }
 
 #endif

include/boost/unordered/unordered_set_fwd.hpp

@@ -17,45 +17,46 @@
 #include <memory>
 
 namespace boost {
-namespace unordered {
+  namespace unordered {
-template <class T, class H = boost::hash<T>, class P = std::equal_to<T>,
+    template <class T, class H = boost::hash<T>, class P = std::equal_to<T>,
       class A = std::allocator<T> >
-class unordered_set;
+    class unordered_set;
 
-template <class T, class H, class P, class A>
+    template <class T, class H, class P, class A>
-inline bool operator==(
+    inline bool operator==(
       unordered_set<T, H, P, A> const&, unordered_set<T, H, P, A> const&);
-template <class T, class H, class P, class A>
+    template <class T, class H, class P, class A>
-inline bool operator!=(
+    inline bool operator!=(
       unordered_set<T, H, P, A> const&, unordered_set<T, H, P, A> const&);
-template <class T, class H, class P, class A>
+    template <class T, class H, class P, class A>
-inline void swap(unordered_set<T, H, P, A>& m1, unordered_set<T, H, P, A>& m2)
+    inline void swap(
+      unordered_set<T, H, P, A>& m1, unordered_set<T, H, P, A>& m2)
       BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)));
 
-template <class T, class H = boost::hash<T>, class P = std::equal_to<T>,
+    template <class T, class H = boost::hash<T>, class P = std::equal_to<T>,
       class A = std::allocator<T> >
-class unordered_multiset;
+    class unordered_multiset;
 
-template <class T, class H, class P, class A>
+    template <class T, class H, class P, class A>
-inline bool operator==(unordered_multiset<T, H, P, A> const&,
+    inline bool operator==(unordered_multiset<T, H, P, A> const&,
       unordered_multiset<T, H, P, A> const&);
-template <class T, class H, class P, class A>
+    template <class T, class H, class P, class A>
-inline bool operator!=(unordered_multiset<T, H, P, A> const&,
+    inline bool operator!=(unordered_multiset<T, H, P, A> const&,
       unordered_multiset<T, H, P, A> const&);
-template <class T, class H, class P, class A>
+    template <class T, class H, class P, class A>
-inline void swap(
+    inline void swap(
       unordered_multiset<T, H, P, A>& m1, unordered_multiset<T, H, P, A>& m2)
       BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)));
 
-template <class N, class T, class A> class node_handle_set;
+    template <class N, class T, class A> class node_handle_set;
-template <class N, class T, class A> struct insert_return_type_set;
+    template <class N, class T, class A> struct insert_return_type_set;
-}
+  }
 
-using boost::unordered::unordered_set;
+  using boost::unordered::unordered_set;
-using boost::unordered::unordered_multiset;
+  using boost::unordered::unordered_multiset;
-using boost::unordered::swap;
+  using boost::unordered::swap;
-using boost::unordered::operator==;
+  using boost::unordered::operator==;
-using boost::unordered::operator!=;
+  using boost::unordered::operator!=;
 }
 
 #endif

test/exception/constructor_exception_tests.cpp

@@ -158,8 +158,7 @@ template <class T> struct range_construct_test5 : public range<T>, objects
 
   void run() const
   {
-        T x(this->values.begin(), this->values.end(), 0, hash, equal_to,
+    T x(this->values.begin(), this->values.end(), 0, hash, equal_to, allocator);
-            allocator);
 
     DISABLE_EXCEPTIONS;
     test::check_container(x, this->values);
@@ -192,8 +191,7 @@ template <class T> struct copy_range_construct_test : public range<T>, objects
   void run() const
   {
     T x(test::copy_iterator(this->values.begin()),
-            test::copy_iterator(this->values.end()), 0, hash, equal_to,
+      test::copy_iterator(this->values.end()), 0, hash, equal_to, allocator);
-            allocator);
 
     DISABLE_EXCEPTIONS;
     test::check_container(x, this->values);

test/exception/copy_exception_tests.cpp

@@ -32,8 +32,7 @@ template <class T> struct copy_test2 : public test::exception_base
   test::random_values<T> values;
   T x;
 
-    copy_test2()
+  copy_test2() : values(5, test::limited_range), x(values.begin(), values.end())
-        : values(5, test::limited_range), x(values.begin(), values.end())
   {
   }
 

test/exception/insert_exception_tests.cpp

@@ -59,8 +59,7 @@ void insert_exception_test_impl(T x, Inserter insert, Values const& v)
   try {
     ENABLE_EXCEPTIONS;
 
-        for (typename Values::const_iterator it = v.begin(); it != v.end();
+    for (typename Values::const_iterator it = v.begin(); it != v.end(); ++it) {
-             ++it) {
       strong.store(x, test::detail::tracker.count_allocations);
       insert(x, it);
     }

test/exception/move_assign_exception_tests.cpp

@@ -121,8 +121,8 @@ template <class T> struct equivalent_test1 : move_assign_base<T>
   }
 };
 
-EXCEPTION_TESTS((move_assign_test1)(move_assign_test2)(move_assign_test3)(
+EXCEPTION_TESTS(
-                    move_assign_test4)(move_assign_test4a)(move_assign_test5)(
+  (move_assign_test1)(move_assign_test2)(move_assign_test3)(move_assign_test4)(
-                    equivalent_test1),
+    move_assign_test4a)(move_assign_test5)(equivalent_test1),
   CONTAINER_SEQ)
 RUN_TESTS()

test/exception/swap_exception_tests.cpp

@@ -18,9 +18,7 @@ test::seed_t initialize_seed(9387);
 template <class T> struct self_swap_base : public test::exception_base
 {
   test::random_values<T> values;
-    self_swap_base(std::size_t count = 0) : values(count, test::limited_range)
+  self_swap_base(std::size_t count = 0) : values(count, test::limited_range) {}
-    {
-    }
 
   typedef T data_type;
   T init() const { return T(values.begin(), values.end()); }
@@ -71,11 +69,10 @@ template <class T> struct swap_base : public test::exception_base
         y_values(count2, test::limited_range),
         initial_x(x_values.begin(), x_values.end(), 0, hasher(tag1),
           key_equal(tag1), allocator_type(tag1)),
-          initial_y(
+        initial_y(y_values.begin(), y_values.end(), 0, hasher(tag2),
-              y_values.begin(), y_values.end(), 0, hasher(tag2),
           key_equal(tag2),
-              allocator_type(
+          allocator_type(T::allocator_type::propagate_on_container_swap::value
-                  T::allocator_type::propagate_on_container_swap::value ? tag2
+                           ? tag2
                            : tag1))
   {
   }

test/helpers/check_return_type.hpp

@@ -11,8 +11,8 @@
 #include <boost/type_traits/is_same.hpp>
 
 namespace test {
-template <class T1> struct check_return_type
+  template <class T1> struct check_return_type
-{
+  {
     template <class T2> static void equals(T2)
     {
       BOOST_STATIC_ASSERT((boost::is_same<T1, T2>::value));
@@ -27,7 +27,7 @@ template <class T1> struct check_return_type
     {
       BOOST_STATIC_ASSERT((boost::is_convertible<T2, T1>::value));
     }
-};
+  };
 }
 
 #endif

test/helpers/count.hpp

@@ -9,8 +9,8 @@
 #include <boost/detail/lightweight_test.hpp>
 
 namespace test {
-struct object_count
+  struct object_count
-{
+  {
     int instances;
     int constructions;
 
@@ -45,26 +45,26 @@ struct object_count
           << ", constructions: " << c.constructions << "]";
       return out;
     }
-};
+  };
 
-// This won't be a problem as I'm only using a single compile unit
+  // This won't be a problem as I'm only using a single compile unit
-// in each test (this is actually require by the minimal test
+  // in each test (this is actually require by the minimal test
-// framework).
+  // framework).
-//
+  //
-// boostinspect:nounnamed
+  // boostinspect:nounnamed
-namespace {
+  namespace {
-object_count global_object_count;
+    object_count global_object_count;
-}
+  }
 
-struct counted_object
+  struct counted_object
-{
+  {
     counted_object() { global_object_count.construct(); }
     counted_object(counted_object const&) { global_object_count.construct(); }
     ~counted_object() { global_object_count.destruct(); }
-};
+  };
 
-struct check_instances
+  struct check_instances
-{
+  {
     int instances_;
     int constructions_;
 
@@ -83,7 +83,7 @@ struct check_instances
     {
       return global_object_count.constructions - constructions_;
     }
-};
+  };
 }
 
 #endif

test/helpers/equivalent.hpp

@@ -15,35 +15,36 @@
 #include <boost/unordered_set.hpp>
 
 namespace test {
-template <class T1, class T2>
+  template <class T1, class T2>
-bool equivalent_impl(T1 const& x, T2 const& y, base_type)
+  bool equivalent_impl(T1 const& x, T2 const& y, base_type)
-{
+  {
     return x == y;
-}
+  }
 
-template <class T>
+  template <class T>
-bool equivalent_impl(boost::hash<T> const&, boost::hash<T> const&, derived_type)
+  bool equivalent_impl(
-{
+    boost::hash<T> const&, boost::hash<T> const&, derived_type)
+  {
     return true;
-}
+  }
 
-template <class T>
+  template <class T>
-bool equivalent_impl(
+  bool equivalent_impl(
     std::equal_to<T> const&, std::equal_to<T> const&, derived_type)
-{
+  {
     return true;
-}
+  }
 
-template <class T1, class T2, class T3, class T4>
+  template <class T1, class T2, class T3, class T4>
-bool equivalent_impl(
+  bool equivalent_impl(
     std::pair<T1, T2> const& x1, std::pair<T3, T4> const& x2, derived_type)
-{
+  {
     return equivalent_impl(x1.first, x2.first, derived) &&
            equivalent_impl(x1.second, x2.second, derived);
-}
+  }
 
-struct equivalent_type
+  struct equivalent_type
-{
+  {
     equivalent_type() {}
 
     template <class T1, class T2>
@@ -51,12 +52,12 @@ struct equivalent_type
     {
       return equivalent_impl(x, y, derived);
     }
-};
+  };
 
-const equivalent_type equivalent;
+  const equivalent_type equivalent;
 
-template <class Container> class unordered_equivalence_tester
+  template <class Container> class unordered_equivalence_tester
-{
+  {
     BOOST_DEDUCED_TYPENAME Container::size_type size_;
     BOOST_DEDUCED_TYPENAME Container::hasher hasher_;
     BOOST_DEDUCED_TYPENAME Container::key_equal key_equal_;
@@ -89,7 +90,7 @@ template <class Container> class unordered_equivalence_tester
 
   private:
     unordered_equivalence_tester();
-};
+  };
 }
 
 #endif

test/helpers/exception_test.hpp

@@ -36,12 +36,10 @@
 #define UNORDERED_EXCEPTION_TEST_POSTFIX RUN_TESTS()
 
 #define EXCEPTION_TESTS(test_seq, param_seq)                                   \
-    BOOST_PP_SEQ_FOR_EACH_PRODUCT(                                             \
+  BOOST_PP_SEQ_FOR_EACH_PRODUCT(EXCEPTION_TESTS_OP, (test_seq)((1))(param_seq))
-        EXCEPTION_TESTS_OP, (test_seq)((1))(param_seq))
 
 #define EXCEPTION_TESTS_REPEAT(n, test_seq, param_seq)                         \
-    BOOST_PP_SEQ_FOR_EACH_PRODUCT(                                             \
+  BOOST_PP_SEQ_FOR_EACH_PRODUCT(EXCEPTION_TESTS_OP, (test_seq)((n))(param_seq))
-        EXCEPTION_TESTS_OP, (test_seq)((n))(param_seq))
 
 #define EXCEPTION_TESTS_OP(r, product)                                         \
   UNORDERED_EXCEPTION_TEST_CASE_REPEAT(                                        \
@@ -51,8 +49,7 @@
     BOOST_PP_SEQ_ELEM(2, product))
 
 #define UNORDERED_SCOPE(scope_name)                                            \
-    for (::test::scope_guard unordered_test_guard(                             \
+  for (::test::scope_guard unordered_test_guard(BOOST_STRINGIZE(scope_name));  \
-             BOOST_STRINGIZE(scope_name));                                     \
        !unordered_test_guard.dismissed(); unordered_test_guard.dismiss())
 
 #define UNORDERED_EPOINT(name)                                                 \
@@ -67,11 +64,11 @@
   ::test::exceptions_enable BOOST_PP_CAT(ENABLE_EXCEPTIONS_, __LINE__)(false)
 
 namespace test {
-static char const* scope = "";
+  static char const* scope = "";
-bool exceptions_enabled = false;
+  bool exceptions_enabled = false;
 
-class scope_guard
+  class scope_guard
-{
+  {
     scope_guard& operator=(scope_guard const&);
     scope_guard(scope_guard const&);
 
@@ -95,10 +92,10 @@ class scope_guard
     void dismiss() { dismissed_ = true; }
 
     bool dismissed() const { return dismissed_; }
-};
+  };
 
-class exceptions_enable
+  class exceptions_enable
-{
+  {
     exceptions_enable& operator=(exceptions_enable const&);
     exceptions_enable(exceptions_enable const&);
 
@@ -127,10 +124,10 @@ class exceptions_enable
         released_ = true;
       }
     }
-};
+  };
 
-struct exception_base
+  struct exception_base
-{
+  {
     struct data_type
     {
     };
@@ -141,33 +138,33 @@ struct exception_base
     };
     data_type init() const { return data_type(); }
     void check BOOST_PREVENT_MACRO_SUBSTITUTION() const {}
-};
+  };
 
-template <class T, class P1, class P2, class T2>
+  template <class T, class P1, class P2, class T2>
-inline void call_ignore_extra_parameters(
+  inline void call_ignore_extra_parameters(
     void (T::*fn)() const, T2 const& obj, P1&, P2&)
-{
+  {
     (obj.*fn)();
-}
+  }
 
-template <class T, class P1, class P2, class T2>
+  template <class T, class P1, class P2, class T2>
-inline void call_ignore_extra_parameters(
+  inline void call_ignore_extra_parameters(
     void (T::*fn)(P1&) const, T2 const& obj, P1& p1, P2&)
-{
+  {
     (obj.*fn)(p1);
-}
+  }
 
-template <class T, class P1, class P2, class T2>
+  template <class T, class P1, class P2, class T2>
-inline void call_ignore_extra_parameters(
+  inline void call_ignore_extra_parameters(
     void (T::*fn)(P1&, P2&) const, T2 const& obj, P1& p1, P2& p2)
-{
+  {
     (obj.*fn)(p1, p2);
-}
+  }
 
-template <class T> T const& constant(T const& x) { return x; }
+  template <class T> T const& constant(T const& x) { return x; }
 
-template <class Test> class test_runner
+  template <class Test> class test_runner
-{
+  {
     Test const& test_;
     bool exception_in_check_;
 
@@ -209,34 +206,35 @@ template <class Test> class test_runner
         BOOST_ERROR("Unexcpected exception in test_runner check call.");
       }
     }
-};
+  };
 
-// Quick exception testing based on lightweight test
+  // Quick exception testing based on lightweight test
 
-namespace lightweight {
+  namespace lightweight {
-static int iteration;
+    static int iteration;
-static int count;
+    static int count;
 
-struct test_exception
+    struct test_exception
-{
+    {
       char const* name;
       test_exception(char const* n) : name(n) {}
-};
+    };
 
-struct test_failure
+    struct test_failure
-{
+    {
-};
+    };
 
-void epoint(char const* name)
+    void epoint(char const* name)
-{
+    {
       ++count;
       if (count == iteration) {
         throw test_exception(name);
       }
-}
+    }
 
-template <class Test> void exception_safety(Test const& f, char const* /*name*/)
+    template <class Test>
-{
+    void exception_safety(Test const& f, char const* /*name*/)
+    {
       test_runner<Test> runner(f);
 
       iteration = 0;
@@ -274,14 +272,14 @@ template <class Test> void exception_safety(Test const& f, char const* /*name*/)
         BOOST_ERROR(error_msg);
       }
       runner.end();
-}
+    }
 
-//
+    //
-// An alternative way to run exception tests.
+    // An alternative way to run exception tests.
-// See merge_exception_tests.cpp for an example.
+    // See merge_exception_tests.cpp for an example.
 
-struct exception_looper
+    struct exception_looper
-{
+    {
       bool success;
       unsigned int failure_count;
       char const* error_msg;
@@ -319,7 +317,10 @@ struct exception_looper
         }
       }
 
-    void unexpected_exception_caught() { error_msg = "Unexpected exception."; }
+      void unexpected_exception_caught()
+      {
+        error_msg = "Unexpected exception.";
+      }
 
       void end()
       {
@@ -327,7 +328,7 @@ struct exception_looper
           BOOST_ERROR(error_msg);
         }
       }
-};
+    };
 
 #define EXCEPTION_LOOP(op)                                                     \
   test::lightweight::exception_looper looper;                                  \
@@ -346,7 +347,7 @@ struct exception_looper
     }                                                                          \
   }                                                                            \
   looper.end();
-}
+  }
 }
 
 #endif

test/helpers/fwd.hpp

@@ -9,24 +9,24 @@
 #include <string>
 
 namespace test {
-typedef enum {
+  typedef enum {
     default_generator,
     generate_collisions,
     limited_range
-} random_generator;
+  } random_generator;
 
-int generate(int const*, random_generator);
+  int generate(int const*, random_generator);
-char generate(char const*, random_generator);
+  char generate(char const*, random_generator);
-signed char generate(signed char const*, random_generator);
+  signed char generate(signed char const*, random_generator);
-std::string generate(std::string const*, random_generator);
+  std::string generate(std::string const*, random_generator);
-float generate(float const*, random_generator);
+  float generate(float const*, random_generator);
 
-struct base_type
+  struct base_type
-{
+  {
-} base;
+  } base;
-struct derived_type : base_type
+  struct derived_type : base_type
-{
+  {
-} derived;
+  } derived;
 }
 
 #endif

test/helpers/generators.hpp

@@ -19,45 +19,45 @@
 #include <utility>
 
 namespace test {
-struct seed_t
+  struct seed_t
-{
+  {
     seed_t(unsigned int x)
     {
       using namespace std;
       srand(x);
     }
-};
+  };
 
-std::size_t random_value(std::size_t max)
+  std::size_t random_value(std::size_t max)
-{
+  {
     using namespace std;
     return static_cast<std::size_t>(rand()) % max;
-}
+  }
 
-inline int generate(int const*, random_generator g)
+  inline int generate(int const*, random_generator g)
-{
+  {
     using namespace std;
     int value = rand();
     if (g == limited_range) {
       value = value % 100;
     }
     return value;
-}
+  }
 
-inline char generate(char const*, random_generator)
+  inline char generate(char const*, random_generator)
-{
+  {
     using namespace std;
     return static_cast<char>((rand() >> 1) % (128 - 32) + 32);
-}
+  }
 
-inline signed char generate(signed char const*, random_generator)
+  inline signed char generate(signed char const*, random_generator)
-{
+  {
     using namespace std;
     return static_cast<signed char>(rand());
-}
+  }
 
-inline std::string generate(std::string const*, random_generator g)
+  inline std::string generate(std::string const*, random_generator g)
-{
+  {
     using namespace std;
 
     char* char_ptr = 0;
@@ -69,8 +69,7 @@ inline std::string generate(std::string const*, random_generator g)
 
       char const* strings[] = {"'vZh(3~ms", "%m", "_Y%U", "N'Y", "4,J_J"};
       for (std::size_t i = 0; i < length; ++i) {
-            result +=
+        result += strings[random_value(sizeof(strings) / sizeof(strings[0]))];
-                strings[random_value(sizeof(strings) / sizeof(strings[0]))];
       }
     } else {
       std::size_t length = test::random_value(10) + 1;
@@ -80,15 +79,15 @@ inline std::string generate(std::string const*, random_generator g)
     }
 
     return result;
-}
+  }
 
-float generate(float const*, random_generator g)
+  float generate(float const*, random_generator g)
-{
+  {
     using namespace std;
     int x = 0;
     int value = generate(&x, g);
     return (float)value / (float)RAND_MAX;
-}
+  }
 }
 
 #endif

test/helpers/helpers.hpp

@@ -7,8 +7,8 @@
 #define BOOST_UNORDERED_TEST_HELPERS_HEADER
 
 namespace test {
-template <class Container> struct get_key_impl
+  template <class Container> struct get_key_impl
-{
+  {
     typedef BOOST_DEDUCED_TYPENAME Container::key_type key_type;
 
     static key_type const& get_key(key_type const& x) { return x; }
@@ -25,29 +25,29 @@ template <class Container> struct get_key_impl
     {
       return x.first;
     }
-};
+  };
 
-template <class Container, class T>
+  template <class Container, class T>
-inline BOOST_DEDUCED_TYPENAME Container::key_type const& get_key(T const& x)
+  inline BOOST_DEDUCED_TYPENAME Container::key_type const& get_key(T const& x)
-{
+  {
     return get_key_impl<Container>::get_key(x);
-}
+  }
 
-// test::next
+  // test::next
-//
+  //
-// Increments an iterator by 1 or a given value.
+  // Increments an iterator by 1 or a given value.
-// Like boost::next, but simpler and slower.
+  // Like boost::next, but simpler and slower.
 
-template <typename Iterator> Iterator next(Iterator it) { return ++it; }
+  template <typename Iterator> Iterator next(Iterator it) { return ++it; }
 
-template <typename Iterator, typename IntType>
+  template <typename Iterator, typename IntType>
-Iterator next(Iterator it, IntType x)
+  Iterator next(Iterator it, IntType x)
-{
+  {
     for (; x > 0; --x) {
       ++it;
     }
     return it;
-}
+  }
 }
 
 #endif

test/helpers/input_iterator.hpp

@@ -11,8 +11,8 @@
 #include <iterator>
 
 namespace test {
-template <class Iterator> struct proxy
+  template <class Iterator> struct proxy
-{
+  {
     typedef BOOST_DEDUCED_TYPENAME Iterator::value_type value_type;
 
     explicit proxy(value_type const& v) : v_(v) {}
@@ -23,16 +23,16 @@ template <class Iterator> struct proxy
 
   private:
     proxy& operator=(proxy const&);
-};
+  };
 
-template <class Iterator>
+  template <class Iterator>
-struct input_iterator_adaptor
+  struct input_iterator_adaptor
     : public std::iterator<std::input_iterator_tag,
         BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type,
         std::ptrdiff_t,
         BOOST_DEDUCED_TYPENAME boost::iterator_pointer<Iterator>::type,
         proxy<Iterator> >
-{
+  {
     typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type
       value_type;
 
@@ -58,23 +58,23 @@ struct input_iterator_adaptor
 
   private:
     Iterator* base_;
-};
+  };
 
-template <class Iterator>
+  template <class Iterator>
-input_iterator_adaptor<Iterator> input_iterator(Iterator& it)
+  input_iterator_adaptor<Iterator> input_iterator(Iterator& it)
-{
+  {
     return input_iterator_adaptor<Iterator>(it);
-}
+  }
 
-template <class Iterator>
+  template <class Iterator>
-struct copy_iterator_adaptor
+  struct copy_iterator_adaptor
     : public std::iterator<
         BOOST_DEDUCED_TYPENAME boost::iterator_category<Iterator>::type,
         BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type,
         BOOST_DEDUCED_TYPENAME boost::iterator_difference<Iterator>::type,
         BOOST_DEDUCED_TYPENAME boost::iterator_pointer<Iterator>::type,
         proxy<Iterator> >
-{
+  {
     typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<Iterator>::type
       value_type;
     typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<Iterator>::type
@@ -161,13 +161,13 @@ struct copy_iterator_adaptor
 
   private:
     Iterator base_;
-};
+  };
 
-template <class Iterator>
+  template <class Iterator>
-copy_iterator_adaptor<Iterator> copy_iterator(Iterator const& it)
+  copy_iterator_adaptor<Iterator> copy_iterator(Iterator const& it)
-{
+  {
     return copy_iterator_adaptor<Iterator>(it);
-}
+  }
 }
 
 #endif

test/helpers/invariants.hpp

@@ -22,8 +22,8 @@
 #endif
 
 namespace test {
-template <class X> void check_equivalent_keys(X const& x1)
+  template <class X> void check_equivalent_keys(X const& x1)
-{
+  {
     BOOST_DEDUCED_TYPENAME X::key_equal eq = x1.key_eq();
     typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
     std::set<key_type, std::less<key_type> > found_;
@@ -71,8 +71,7 @@ template <class X> void check_equivalent_keys(X const& x1)
 
       if (lit == lend) {
         BOOST_ERROR("Unable to find element with a local_iterator");
-            std::cerr << "Checked: " << count_checked << " elements"
+        std::cerr << "Checked: " << count_checked << " elements" << std::endl;
-                      << std::endl;
       } else {
         unsigned int count2 = 0;
         for (; lit != lend && eq(get_key<X>(*lit), key); ++lit)
@@ -98,8 +97,7 @@ template <class X> void check_equivalent_keys(X const& x1)
 
     // Check the load factor.
 
-    float load_factor =
+    float load_factor = size == 0 ? 0 : static_cast<float>(size) /
-        size == 0 ? 0 : static_cast<float>(size) /
                                           static_cast<float>(x1.bucket_count());
     using namespace std;
     if (fabs(x1.load_factor() - load_factor) > x1.load_factor() / 64)
@@ -111,8 +109,7 @@ template <class X> void check_equivalent_keys(X const& x1)
 
     for (BOOST_DEDUCED_TYPENAME X::size_type i = 0; i < x1.bucket_count();
          ++i) {
-        for (BOOST_DEDUCED_TYPENAME X::const_local_iterator
+      for (BOOST_DEDUCED_TYPENAME X::const_local_iterator begin2 = x1.begin(i),
-                 begin2 = x1.begin(i),
                                                           end2 = x1.end(i);
            begin2 != end2; ++begin2) {
         ++bucket_size;
@@ -123,7 +120,7 @@ template <class X> void check_equivalent_keys(X const& x1)
       BOOST_ERROR("x1.size() doesn't match bucket size.");
       std::cout << x1.size() << "/" << bucket_size << std::endl;
     }
-}
+  }
 }
 
 #if defined(BOOST_MSVC)

test/helpers/list.hpp

@@ -16,34 +16,34 @@
 #include <iterator>
 
 namespace test {
-template <typename It1, typename It2>
+  template <typename It1, typename It2>
-bool equal(It1 begin, It1 end, It2 compare)
+  bool equal(It1 begin, It1 end, It2 compare)
-{
+  {
     for (; begin != end; ++begin, ++compare)
       if (*begin != *compare)
         return false;
     return true;
-}
+  }
 
-template <typename It1, typename It2, typename Pred>
+  template <typename It1, typename It2, typename Pred>
-bool equal(It1 begin, It1 end, It2 compare, Pred predicate)
+  bool equal(It1 begin, It1 end, It2 compare, Pred predicate)
-{
+  {
     for (; begin != end; ++begin, ++compare)
       if (!predicate(*begin, *compare))
         return false;
     return true;
-}
+  }
 
-template <typename T> class list;
+  template <typename T> class list;
 
-namespace test_detail {
+  namespace test_detail {
-template <typename T> class list_node;
+    template <typename T> class list_node;
-template <typename T> class list_data;
+    template <typename T> class list_data;
-template <typename T> class list_iterator;
+    template <typename T> class list_iterator;
-template <typename T> class list_const_iterator;
+    template <typename T> class list_const_iterator;
 
-template <typename T> class list_node
+    template <typename T> class list_node
-{
+    {
       list_node(list_node const&);
       list_node& operator=(list_node const&);
 
@@ -53,10 +53,10 @@ template <typename T> class list_node
 
       list_node(T const& v) : value_(v), next_(0) {}
       list_node(T const& v, list_node* n) : value_(v), next_(n) {}
-};
+    };
 
-template <typename T> class list_data
+    template <typename T> class list_data
-{
+    {
     public:
       typedef list_node<T> node;
       typedef unsigned int size_type;
@@ -79,12 +79,12 @@ template <typename T> class list_data
     private:
       list_data(list_data const&);
       list_data& operator=(list_data const&);
-};
+    };
 
-template <typename T>
+    template <typename T>
-class list_iterator
+    class list_iterator
       : public std::iterator<std::forward_iterator_tag, T, int, T*, T&>
-{
+    {
       friend class list_const_iterator<T>;
       friend class test::list<T>;
       typedef list_node<T> node;
@@ -111,12 +111,12 @@ class list_iterator
       }
       bool operator==(const_iterator y) const { return ptr_ == y.ptr_; }
       bool operator!=(const_iterator y) const { return ptr_ != y.ptr_; }
-};
+    };
 
-template <typename T>
+    template <typename T>
-class list_const_iterator : public std::iterator<std::forward_iterator_tag, T,
+    class list_const_iterator : public std::iterator<std::forward_iterator_tag,
-                                int, T const*, T const&>
+                                  T, int, T const*, T const&>
-{
+    {
       friend class list_iterator<T>;
       friend class test::list<T>;
       typedef list_node<T> node;
@@ -148,11 +148,11 @@ class list_const_iterator : public std::iterator<std::forward_iterator_tag, T,
       bool operator==(const_iterator y) const { return ptr_ == y.ptr_; }
 
       bool operator!=(const_iterator y) const { return ptr_ != y.ptr_; }
-};
+    };
-}
+  }
 
-template <typename T> class list
+  template <typename T> class list
-{
+  {
     typedef test::test_detail::list_data<T> data;
     typedef test::test_detail::list_node<T> node;
     data data_;
@@ -267,8 +267,7 @@ template <typename T> class list
     {
       node** ptr = &(*l)->next_;
       for (size_type count = 0; count < recurse_limit && *ptr; ++count) {
-            ptr = merge_adjacent_ranges(
+        ptr = merge_adjacent_ranges(l, ptr, merge_sort(ptr, count, less), less);
-                l, ptr, merge_sort(ptr, count, less), less);
       }
       return ptr;
     }
@@ -314,7 +313,7 @@ template <typename T> class list
       if (!*second)
         data_.last_ptr_ = second;
     }
-};
+  };
 }
 
 #endif

test/helpers/memory.hpp

@@ -13,9 +13,9 @@
 #include <memory>
 
 namespace test {
-namespace detail {
+  namespace detail {
-struct memory_area
+    struct memory_area
-{
+    {
       void const* start;
       void const* end;
 
@@ -23,35 +23,35 @@ struct memory_area
       {
         BOOST_ASSERT(start != end);
       }
-};
+    };
 
-struct memory_track
+    struct memory_track
-{
+    {
       explicit memory_track(int tag = -1) : constructed_(0), tag_(tag) {}
 
       int constructed_;
       int tag_;
-};
+    };
 
-// This is a bit dodgy as it defines overlapping
+    // This is a bit dodgy as it defines overlapping
-// areas as 'equal', so this isn't a total ordering.
+    // areas as 'equal', so this isn't a total ordering.
-// But it is for non-overlapping memory regions - which
+    // But it is for non-overlapping memory regions - which
-// is what'll be stored.
+    // is what'll be stored.
-//
+    //
-// All searches will be for areas entirely contained by
+    // All searches will be for areas entirely contained by
-// a member of the set - so it should find the area that contains
+    // a member of the set - so it should find the area that contains
-// the region that is searched for.
+    // the region that is searched for.
 
-struct memory_area_compare
+    struct memory_area_compare
-{
+    {
       bool operator()(memory_area const& x, memory_area const& y) const
       {
         return x.end <= y.start;
       }
-};
+    };
 
-struct memory_tracker
+    struct memory_tracker
-{
+    {
       typedef std::map<memory_area, memory_track, memory_area_compare,
         std::allocator<std::pair<memory_area const, memory_track> > >
         allocated_memory_type;
@@ -148,23 +148,23 @@ struct memory_tracker
             --count_constructions;
         }
       }
-};
+    };
-}
+  }
 
-namespace detail {
+  namespace detail {
-// This won't be a problem as I'm only using a single compile unit
+    // This won't be a problem as I'm only using a single compile unit
-// in each test (this is actually required by the minimal test
+    // in each test (this is actually required by the minimal test
-// framework).
+    // framework).
-//
+    //
-// boostinspect:nounnamed
+    // boostinspect:nounnamed
-namespace {
+    namespace {
-test::detail::memory_tracker tracker;
+      test::detail::memory_tracker tracker;
-}
+    }
-}
+  }
 
-namespace detail {
+  namespace detail {
-struct disable_construction_tracking
+    struct disable_construction_tracking
-{
+    {
       bool old_value;
 
       disable_construction_tracking()
@@ -182,8 +182,8 @@ struct disable_construction_tracking
       disable_construction_tracking(disable_construction_tracking const&);
       disable_construction_tracking& operator=(
         disable_construction_tracking const&);
-};
+    };
-}
+  }
 }
 
 #endif

test/helpers/metafunctions.hpp

@@ -10,25 +10,25 @@
 #include <boost/type_traits/is_same.hpp>
 
 namespace test {
-template <class Container>
+  template <class Container>
-struct is_set
+  struct is_set
     : public boost::is_same<BOOST_DEDUCED_TYPENAME Container::key_type,
         BOOST_DEDUCED_TYPENAME Container::value_type>
-{
+  {
-};
+  };
 
-template <class Container> struct has_unique_keys
+  template <class Container> struct has_unique_keys
-{
+  {
     static char flip(BOOST_DEDUCED_TYPENAME Container::iterator const&);
     static long flip(
       std::pair<BOOST_DEDUCED_TYPENAME Container::iterator, bool> const&);
     BOOST_STATIC_CONSTANT(bool,
       value = sizeof(long) ==
-                sizeof(flip(
+              sizeof(
-                    ((Container*)0)
+                flip(((Container*)0)
-                        ->insert(*(
+                       ->insert(
-                            BOOST_DEDUCED_TYPENAME Container::value_type*)0))));
+                         *(BOOST_DEDUCED_TYPENAME Container::value_type*)0))));
-};
+  };
 }
 
 #endif

test/helpers/random_values.hpp

@@ -13,8 +13,8 @@
 #include <boost/detail/select_type.hpp>
 
 namespace test {
-template <class X> struct unordered_generator_set
+  template <class X> struct unordered_generator_set
-{
+  {
     typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
 
     random_generator type_;
@@ -37,10 +37,10 @@ template <class X> struct unordered_generator_set
         }
       }
     }
-};
+  };
 
-template <class X> struct unordered_generator_map
+  template <class X> struct unordered_generator_map
-{
+  {
     typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
     typedef BOOST_DEDUCED_TYPENAME X::mapped_type mapped_type;
 
@@ -65,30 +65,30 @@ template <class X> struct unordered_generator_map
         }
       }
     }
-};
+  };
 
-template <class X>
+  template <class X>
-struct unordered_generator_base
+  struct unordered_generator_base
     : public boost::detail::if_true<test::is_set<X>::value>::
         BOOST_NESTED_TEMPLATE then<test::unordered_generator_set<X>,
           test::unordered_generator_map<X> >
-{
+  {
-};
+  };
 
-template <class X>
+  template <class X>
-struct unordered_generator : public unordered_generator_base<X>::type
+  struct unordered_generator : public unordered_generator_base<X>::type
-{
+  {
     typedef BOOST_DEDUCED_TYPENAME unordered_generator_base<X>::type base;
 
     unordered_generator(random_generator const& type = default_generator)
         : base(type)
     {
     }
-};
+  };
 
-template <class X>
+  template <class X>
-struct random_values : public test::list<BOOST_DEDUCED_TYPENAME X::value_type>
+  struct random_values : public test::list<BOOST_DEDUCED_TYPENAME X::value_type>
-{
+  {
     random_values() {}
 
     explicit random_values(std::size_t count,
@@ -103,7 +103,7 @@ struct random_values : public test::list<BOOST_DEDUCED_TYPENAME X::value_type>
       test::unordered_generator<X> gen(generator);
       gen.fill(*this, count);
     }
-};
+  };
 }
 
 #endif

test/helpers/strong.hpp

@@ -13,8 +13,8 @@
 #include <iterator>
 
 namespace test {
-template <class X> class strong
+  template <class X> class strong
-{
+  {
     typedef test::list<BOOST_DEDUCED_TYPENAME X::value_type> values_type;
     values_type values_;
     unsigned int allocations_;
@@ -30,14 +30,13 @@ template <class X> class strong
 
     void test(X const& x, unsigned int allocations = 0) const
     {
-        if (!(x.size() == values_.size() &&
+      if (!(x.size() == values_.size() && test::equal(x.cbegin(), x.cend(),
-                test::equal(
+                                            values_.begin(), test::equivalent)))
-                    x.cbegin(), x.cend(), values_.begin(), test::equivalent)))
         BOOST_ERROR("Strong exception safety failure.");
       if (allocations != allocations_)
         BOOST_ERROR("Strong exception failure: extra allocations.");
     }
-};
+  };
 }
 
 #endif

test/helpers/test.hpp

@@ -47,17 +47,17 @@
 
 namespace test {
 
-struct registered_test_base
+  struct registered_test_base
-{
+  {
     registered_test_base* next;
     char const* name;
     explicit registered_test_base(char const* n) : name(n) {}
     virtual void run() = 0;
     virtual ~registered_test_base() {}
-};
+  };
 
-struct state
+  struct state
-{
+  {
     bool is_quiet;
     registered_test_base* first_test;
     registered_test_base* last_test;
@@ -87,8 +87,7 @@ struct state
         i->run();
         BOOST_LIGHTWEIGHT_TEST_OSTREAM << std::flush;
         if (quiet && error_count != boost::detail::test_errors()) {
-                BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Error in: " << i->name
+          BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Error in: " << i->name << "\n"
-                                               << "\n"
                                          << std::flush;
         }
       }
@@ -107,20 +106,19 @@ struct state
     int end_sub_test(char const* name, int value)
     {
       if (is_quiet && value != boost::detail::test_errors() + 1) {
-            BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Error in sub-test: " << name
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Error in sub-test: " << name << "\n"
-                                           << "\n"
                                        << std::flush;
       }
       return 0;
     }
-};
+  };
 
-// Get the currnet translation unit's test state.
+  // Get the currnet translation unit's test state.
-static inline state& get_state()
+  static inline state& get_state()
-{
+  {
     static state instance;
     return instance;
-}
+  }
 }
 
 #if defined(__cplusplus)
@@ -137,8 +135,8 @@ static inline state& get_state()
       << "__cplusplus: " << BOOST_UNORDERED_CPLUSPLUS << "\n\n"                \
       << "BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT: "                          \
       << BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT << "\n"                      \
-            << "BOOST_UNORDERED_EMPLACE_LIMIT: "                               \
+      << "BOOST_UNORDERED_EMPLACE_LIMIT: " << BOOST_UNORDERED_EMPLACE_LIMIT    \
-            << BOOST_UNORDERED_EMPLACE_LIMIT << "\n"                           \
+      << "\n"                                                                  \
       << "BOOST_UNORDERED_USE_ALLOCATOR_TRAITS: "                              \
       << BOOST_UNORDERED_USE_ALLOCATOR_TRAITS << "\n"                          \
       << "BOOST_UNORDERED_CXX11_CONSTRUCTION: "                                \

test/helpers/tracker.hpp

@@ -20,18 +20,18 @@
 #include <set>
 
 namespace test {
-template <typename X> struct equals_to_compare
+  template <typename X> struct equals_to_compare
-{
+  {
     typedef std::less<BOOST_DEDUCED_TYPENAME X::first_argument_type> type;
-};
+  };
 
-template <> struct equals_to_compare<test::equal_to>
+  template <> struct equals_to_compare<test::equal_to>
-{
+  {
     typedef test::less type;
-};
+  };
 
-template <class X1, class X2> void compare_range(X1 const& x1, X2 const& x2)
+  template <class X1, class X2> void compare_range(X1 const& x1, X2 const& x2)
-{
+  {
     typedef test::list<BOOST_DEDUCED_TYPENAME X1::value_type> value_list;
     value_list values1(x1.begin(), x1.end());
     value_list values2(x2.begin(), x2.end());
@@ -40,11 +40,11 @@ template <class X1, class X2> void compare_range(X1 const& x1, X2 const& x2)
     BOOST_TEST(values1.size() == values2.size() &&
                test::equal(values1.begin(), values1.end(), values2.begin(),
                  test::equivalent));
-}
+  }
 
-template <class X1, class X2, class T>
+  template <class X1, class X2, class T>
-void compare_pairs(X1 const& x1, X2 const& x2, T*)
+  void compare_pairs(X1 const& x1, X2 const& x2, T*)
-{
+  {
     test::list<T> values1(x1.first, x1.second);
     test::list<T> values2(x2.first, x2.second);
     values1.sort();
@@ -52,48 +52,48 @@ void compare_pairs(X1 const& x1, X2 const& x2, T*)
     BOOST_TEST(values1.size() == values2.size() &&
                test::equal(values1.begin(), values1.end(), values2.begin(),
                  test::equivalent));
-}
+  }
 
-template <typename X, bool is_set = test::is_set<X>::value,
+  template <typename X, bool is_set = test::is_set<X>::value,
     bool has_unique_keys = test::has_unique_keys<X>::value>
-struct ordered_base;
+  struct ordered_base;
 
-template <typename X> struct ordered_base<X, true, true>
+  template <typename X> struct ordered_base<X, true, true>
-{
+  {
     typedef std::set<BOOST_DEDUCED_TYPENAME X::value_type,
       BOOST_DEDUCED_TYPENAME
         equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>
       type;
-};
+  };
 
-template <typename X> struct ordered_base<X, true, false>
+  template <typename X> struct ordered_base<X, true, false>
-{
+  {
     typedef std::multiset<BOOST_DEDUCED_TYPENAME X::value_type,
       BOOST_DEDUCED_TYPENAME
         equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>
       type;
-};
+  };
 
-template <typename X> struct ordered_base<X, false, true>
+  template <typename X> struct ordered_base<X, false, true>
-{
+  {
     typedef std::map<BOOST_DEDUCED_TYPENAME X::key_type,
       BOOST_DEDUCED_TYPENAME X::mapped_type,
       BOOST_DEDUCED_TYPENAME
         equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>
       type;
-};
+  };
 
-template <typename X> struct ordered_base<X, false, false>
+  template <typename X> struct ordered_base<X, false, false>
-{
+  {
     typedef std::multimap<BOOST_DEDUCED_TYPENAME X::key_type,
       BOOST_DEDUCED_TYPENAME X::mapped_type,
       BOOST_DEDUCED_TYPENAME
         equals_to_compare<BOOST_DEDUCED_TYPENAME X::key_equal>::type>
       type;
-};
+  };
 
-template <class X> class ordered : public ordered_base<X>::type
+  template <class X> class ordered : public ordered_base<X>::type
-{
+  {
     typedef BOOST_DEDUCED_TYPENAME ordered_base<X>::type base;
 
   public:
@@ -120,28 +120,28 @@ template <class X> class ordered : public ordered_base<X>::type
         ++b;
       }
     }
-};
+  };
 
-template <class Equals>
+  template <class Equals>
-BOOST_DEDUCED_TYPENAME equals_to_compare<Equals>::type create_compare(
+  BOOST_DEDUCED_TYPENAME equals_to_compare<Equals>::type create_compare(
     Equals const&)
-{
+  {
     BOOST_DEDUCED_TYPENAME equals_to_compare<Equals>::type x;
     return x;
-}
+  }
 
-template <class X> ordered<X> create_ordered(X const& container)
+  template <class X> ordered<X> create_ordered(X const& container)
-{
+  {
     return ordered<X>(create_compare(container.key_eq()));
-}
+  }
 
-template <class X1, class X2>
+  template <class X1, class X2>
-void check_container(X1 const& container, X2 const& values)
+  void check_container(X1 const& container, X2 const& values)
-{
+  {
     ordered<X1> tracker = create_ordered(container);
     tracker.insert_range(values.begin(), values.end());
     tracker.compare(container);
-}
+  }
 }
 
 #endif

test/objects/cxx11_allocator.hpp

@@ -14,8 +14,8 @@
 #include "../helpers/memory.hpp"
 
 namespace test {
-struct allocator_false
+  struct allocator_false
-{
+  {
     enum
     {
       is_select_on_copy = 0,
@@ -24,10 +24,10 @@ struct allocator_false
       is_propagate_on_move = 0,
       cxx11_construct = 0
     };
-};
+  };
 
-struct allocator_flags_all
+  struct allocator_flags_all
-{
+  {
     enum
     {
       is_select_on_copy = 1,
@@ -36,68 +36,68 @@ struct allocator_flags_all
       is_propagate_on_move = 1,
       cxx11_construct = 1
     };
-};
+  };
 
-struct select_copy : allocator_false
+  struct select_copy : allocator_false
-{
+  {
     enum
     {
       is_select_on_copy = 1
     };
-};
+  };
-struct propagate_swap : allocator_false
+  struct propagate_swap : allocator_false
-{
+  {
     enum
     {
       is_propagate_on_swap = 1
     };
-};
+  };
-struct propagate_assign : allocator_false
+  struct propagate_assign : allocator_false
-{
+  {
     enum
     {
       is_propagate_on_assign = 1
     };
-};
+  };
-struct propagate_move : allocator_false
+  struct propagate_move : allocator_false
-{
+  {
     enum
     {
       is_propagate_on_move = 1
     };
-};
+  };
 
-struct no_select_copy : allocator_flags_all
+  struct no_select_copy : allocator_flags_all
-{
+  {
     enum
     {
       is_select_on_copy = 0
     };
-};
+  };
-struct no_propagate_swap : allocator_flags_all
+  struct no_propagate_swap : allocator_flags_all
-{
+  {
     enum
     {
       is_propagate_on_swap = 0
     };
-};
+  };
-struct no_propagate_assign : allocator_flags_all
+  struct no_propagate_assign : allocator_flags_all
-{
+  {
     enum
     {
       is_propagate_on_assign = 0
     };
-};
+  };
-struct no_propagate_move : allocator_flags_all
+  struct no_propagate_move : allocator_flags_all
-{
+  {
     enum
     {
       is_propagate_on_move = 0
     };
-};
+  };
 
-template <typename Flag> struct swap_allocator_base
+  template <typename Flag> struct swap_allocator_base
-{
+  {
     struct propagate_on_container_swap
     {
       enum
@@ -105,10 +105,10 @@ template <typename Flag> struct swap_allocator_base
         value = Flag::is_propagate_on_swap
       };
     };
-};
+  };
 
-template <typename Flag> struct assign_allocator_base
+  template <typename Flag> struct assign_allocator_base
-{
+  {
     struct propagate_on_container_copy_assignment
     {
       enum
@@ -116,10 +116,10 @@ template <typename Flag> struct assign_allocator_base
         value = Flag::is_propagate_on_assign
       };
     };
-};
+  };
 
-template <typename Flag> struct move_allocator_base
+  template <typename Flag> struct move_allocator_base
-{
+  {
     struct propagate_on_container_move_assignment
     {
       enum
@@ -127,15 +127,15 @@ template <typename Flag> struct move_allocator_base
         value = Flag::is_propagate_on_move
       };
     };
-};
+  };
 
-namespace {
+  namespace {
-// boostinspect:nounnamed
+    // boostinspect:nounnamed
-bool force_equal_allocator_value = false;
+    bool force_equal_allocator_value = false;
-}
+  }
 
-struct force_equal_allocator
+  struct force_equal_allocator
-{
+  {
     bool old_value_;
 
     explicit force_equal_allocator(bool value)
@@ -145,10 +145,10 @@ struct force_equal_allocator
     }
 
     ~force_equal_allocator() { force_equal_allocator_value = old_value_; }
-};
+  };
 
-template <typename T> struct cxx11_allocator_base
+  template <typename T> struct cxx11_allocator_base
-{
+  {
     int tag_;
     int selected_;
 
@@ -233,20 +233,20 @@ template <typename T> struct cxx11_allocator_base
     {
       return (std::numeric_limits<size_type>::max)();
     }
-};
+  };
 
-template <typename T, typename Flags = propagate_swap, typename Enable = void>
+  template <typename T, typename Flags = propagate_swap, typename Enable = void>
-struct cxx11_allocator;
+  struct cxx11_allocator;
 
-template <typename T, typename Flags>
+  template <typename T, typename Flags>
-struct cxx11_allocator<T, Flags,
+  struct cxx11_allocator<T, Flags,
     typename boost::disable_if_c<Flags::is_select_on_copy>::type>
     : public cxx11_allocator_base<T>,
       public swap_allocator_base<Flags>,
       public assign_allocator_base<Flags>,
       public move_allocator_base<Flags>,
       Flags
-{
+  {
 #if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 402000)
     template <typename U> struct rebind
     {
@@ -272,17 +272,17 @@ struct cxx11_allocator<T, Flags,
     }
 
     bool operator!=(cxx11_allocator const& x) const { return !(*this == x); }
-};
+  };
 
-template <typename T, typename Flags>
+  template <typename T, typename Flags>
-struct cxx11_allocator<T, Flags,
+  struct cxx11_allocator<T, Flags,
     typename boost::enable_if_c<Flags::is_select_on_copy>::type>
     : public cxx11_allocator_base<T>,
       public swap_allocator_base<Flags>,
       public assign_allocator_base<Flags>,
       public move_allocator_base<Flags>,
       Flags
-{
+  {
     cxx11_allocator select_on_container_copy_construction() const
     {
       cxx11_allocator tmp(*this);
@@ -315,30 +315,30 @@ struct cxx11_allocator<T, Flags,
     }
 
     bool operator!=(cxx11_allocator const& x) const { return !(*this == x); }
-};
+  };
 
-template <typename T, typename Flags>
+  template <typename T, typename Flags>
-bool equivalent_impl(cxx11_allocator<T, Flags> const& x,
+  bool equivalent_impl(cxx11_allocator<T, Flags> const& x,
     cxx11_allocator<T, Flags> const& y, test::derived_type)
-{
+  {
     return x.tag_ == y.tag_;
-}
+  }
 
-// Function to check how many times an allocator has been selected,
+  // Function to check how many times an allocator has been selected,
-// return 0 for other allocators.
+  // return 0 for other allocators.
 
-struct convert_from_anything
+  struct convert_from_anything
-{
+  {
     template <typename T> convert_from_anything(T const&) {}
-};
+  };
 
-inline int selected_count(convert_from_anything) { return 0; }
+  inline int selected_count(convert_from_anything) { return 0; }
 
-template <typename T, typename Flags>
+  template <typename T, typename Flags>
-int selected_count(cxx11_allocator<T, Flags> const& x)
+  int selected_count(cxx11_allocator<T, Flags> const& x)
-{
+  {
     return x.selected_;
-}
+  }
 }
 
 #endif

test/objects/exception.hpp

@@ -18,33 +18,33 @@
 #include <new>
 
 namespace test {
-namespace exception {
+  namespace exception {
-class object;
+    class object;
-class hash;
+    class hash;
-class equal_to;
+    class equal_to;
-template <class T> class allocator;
+    template <class T> class allocator;
-object generate(object const*, random_generator);
+    object generate(object const*, random_generator);
-std::pair<object, object> generate(
+    std::pair<object, object> generate(
       std::pair<object, object> const*, random_generator);
 
-struct true_type
+    struct true_type
-{
+    {
       enum
       {
         value = true
       };
-};
+    };
 
-struct false_type
+    struct false_type
-{
+    {
       enum
       {
         value = false
       };
-};
+    };
 
-class object : private counted_object
+    class object : private counted_object
-{
+    {
     public:
       int tag1_, tag2_;
 
@@ -64,7 +64,8 @@ class object : private counted_object
         }
       }
 
-    object(object const& x) : counted_object(x), tag1_(x.tag1_), tag2_(x.tag2_)
+      object(object const& x)
+          : counted_object(x), tag1_(x.tag1_), tag2_(x.tag2_)
       {
         UNORDERED_SCOPE(object::object(object))
         {
@@ -128,19 +129,19 @@ class object : private counted_object
       {
         return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
       }
-};
+    };
 
-std::pair<object, object> generate(
+    std::pair<object, object> generate(
       std::pair<object, object> const*, random_generator g)
-{
+    {
       int* x = 0;
       return std::make_pair(
         object(::test::generate(x, g), ::test::generate(x, g)),
         object(::test::generate(x, g), ::test::generate(x, g)));
-}
+    }
 
-class hash
+    class hash
-{
+    {
       int tag_;
 
     public:
@@ -224,10 +225,10 @@ class hash
         }
         return x1.tag_ != x2.tag_;
       }
-};
+    };
 
-class less
+    class less
-{
+    {
       int tag_;
 
     public:
@@ -273,10 +274,10 @@ class less
       {
         return x1.tag_ != x2.tag_;
       }
-};
+    };
 
-class equal_to
+    class equal_to
-{
+    {
       int tag_;
 
     public:
@@ -361,10 +362,10 @@ class equal_to
       }
 
       friend less create_compare(equal_to x) { return less(x.tag_); }
-};
+    };
 
-template <class T> class allocator
+    template <class T> class allocator
-{
+    {
     public:
       int tag_;
       typedef std::size_t size_type;
@@ -467,8 +468,7 @@ template <class T> class allocator
       {
         //::operator delete((void*) p);
         if (p) {
-            test::detail::tracker.track_deallocate(
+          test::detail::tracker.track_deallocate((void*)p, n, sizeof(T), tag_);
-                (void*)p, n, sizeof(T), tag_);
           using namespace std;
           free(p);
         }
@@ -514,36 +514,36 @@ template <class T> class allocator
       typedef true_type propagate_on_container_copy_assignment;
       typedef true_type propagate_on_container_move_assignment;
       typedef true_type propagate_on_container_swap;
-};
+    };
 
-template <class T> void swap(allocator<T>& x, allocator<T>& y)
+    template <class T> void swap(allocator<T>& x, allocator<T>& y)
-{
+    {
       std::swap(x.tag_, y.tag_);
-}
+    }
 
-// It's pretty much impossible to write a compliant swap when these
+    // It's pretty much impossible to write a compliant swap when these
-// two can throw. So they don't.
+    // two can throw. So they don't.
 
-template <class T>
+    template <class T>
-inline bool operator==(allocator<T> const& x, allocator<T> const& y)
+    inline bool operator==(allocator<T> const& x, allocator<T> const& y)
-{
+    {
       // UNORDERED_SCOPE(operator==(allocator, allocator)) {
       //    UNORDERED_EPOINT("Mock allocator equality operator.");
       //}
       return x.tag_ == y.tag_;
-}
+    }
 
-template <class T>
+    template <class T>
-inline bool operator!=(allocator<T> const& x, allocator<T> const& y)
+    inline bool operator!=(allocator<T> const& x, allocator<T> const& y)
-{
+    {
       // UNORDERED_SCOPE(operator!=(allocator, allocator)) {
       //    UNORDERED_EPOINT("Mock allocator inequality operator.");
       //}
       return x.tag_ != y.tag_;
-}
+    }
 
-template <class T> class allocator2
+    template <class T> class allocator2
-{
+    {
     public:
       int tag_;
       typedef std::size_t size_type;
@@ -647,8 +647,7 @@ template <class T> class allocator2
       {
         //::operator delete((void*) p);
         if (p) {
-            test::detail::tracker.track_deallocate(
+          test::detail::tracker.track_deallocate((void*)p, n, sizeof(T), tag_);
-                (void*)p, n, sizeof(T), tag_);
           using namespace std;
           free(p);
         }
@@ -694,59 +693,59 @@ template <class T> class allocator2
       typedef false_type propagate_on_container_copy_assignment;
       typedef false_type propagate_on_container_move_assignment;
       typedef false_type propagate_on_container_swap;
-};
+    };
 
-template <class T> void swap(allocator2<T>& x, allocator2<T>& y)
+    template <class T> void swap(allocator2<T>& x, allocator2<T>& y)
-{
+    {
       std::swap(x.tag_, y.tag_);
-}
+    }
 
-// It's pretty much impossible to write a compliant swap when these
+    // It's pretty much impossible to write a compliant swap when these
-// two can throw. So they don't.
+    // two can throw. So they don't.
 
-template <class T>
+    template <class T>
-inline bool operator==(allocator2<T> const& x, allocator2<T> const& y)
+    inline bool operator==(allocator2<T> const& x, allocator2<T> const& y)
-{
+    {
       // UNORDERED_SCOPE(operator==(allocator2, allocator2)) {
       //    UNORDERED_EPOINT("Mock allocator2 equality operator.");
       //}
       return x.tag_ == y.tag_;
-}
+    }
 
-template <class T>
+    template <class T>
-inline bool operator!=(allocator2<T> const& x, allocator2<T> const& y)
+    inline bool operator!=(allocator2<T> const& x, allocator2<T> const& y)
-{
+    {
       // UNORDERED_SCOPE(operator!=(allocator2, allocator2)) {
       //    UNORDERED_EPOINT("Mock allocator2 inequality operator.");
       //}
       return x.tag_ != y.tag_;
-}
+    }
-}
+  }
 }
 
 namespace test {
-template <typename X> struct equals_to_compare;
+  template <typename X> struct equals_to_compare;
-template <> struct equals_to_compare<test::exception::equal_to>
+  template <> struct equals_to_compare<test::exception::equal_to>
-{
+  {
     typedef test::exception::less type;
-};
+  };
 }
 
 // Workaround for ADL deficient compilers
 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
 namespace test {
-test::exception::object generate(
+  test::exception::object generate(
     test::exception::object const* x, random_generator g)
-{
+  {
     return test::exception::generate(x, g);
-}
+  }
 
-std::pair<test::exception::object, test::exception::object> generate(
+  std::pair<test::exception::object, test::exception::object> generate(
     std::pair<test::exception::object, test::exception::object> const* x,
     random_generator g)
-{
+  {
     return test::exception::generate(x, g);
-}
+  }
 }
 #endif
 

test/objects/fwd.hpp

@@ -7,11 +7,11 @@
 #define BOOST_UNORDERED_TEST_OBJECTS_FWD_HEADER
 
 namespace test {
-class object;
+  class object;
-class hash;
+  class hash;
-class less;
+  class less;
-class equal_to;
+  class equal_to;
-template <class T> class allocator;
+  template <class T> class allocator;
 }
 
 #endif

test/objects/minimal.hpp

@@ -26,32 +26,32 @@
 #endif
 
 namespace test {
-namespace minimal {
+  namespace minimal {
-class destructible;
+    class destructible;
-class copy_constructible;
+    class copy_constructible;
-class copy_constructible_equality_comparable;
+    class copy_constructible_equality_comparable;
-class default_assignable;
+    class default_assignable;
-class assignable;
+    class assignable;
 
-struct ampersand_operator_used
+    struct ampersand_operator_used
-{
+    {
       ampersand_operator_used() { BOOST_TEST(false); }
-};
+    };
 
-template <class T> class hash;
+    template <class T> class hash;
-template <class T> class equal_to;
+    template <class T> class equal_to;
-template <class T> class ptr;
+    template <class T> class ptr;
-template <class T> class const_ptr;
+    template <class T> class const_ptr;
-template <class T> class allocator;
+    template <class T> class allocator;
-template <class T> class cxx11_allocator;
+    template <class T> class cxx11_allocator;
 
-struct constructor_param
+    struct constructor_param
-{
+    {
       operator int() const { return 0; }
-};
+    };
 
-class destructible
+    class destructible
-{
+    {
     public:
       destructible(constructor_param const&) {}
       ~destructible() {}
@@ -59,10 +59,10 @@ class destructible
     private:
       destructible(destructible const&);
       destructible& operator=(destructible const&);
-};
+    };
 
-class copy_constructible
+    class copy_constructible
-{
+    {
     public:
       copy_constructible(constructor_param const&) {}
       copy_constructible(copy_constructible const&) {}
@@ -71,10 +71,10 @@ class copy_constructible
     private:
       copy_constructible& operator=(copy_constructible const&);
       copy_constructible() {}
-};
+    };
 
-class copy_constructible_equality_comparable
+    class copy_constructible_equality_comparable
-{
+    {
     public:
       copy_constructible_equality_comparable(constructor_param const&) {}
 
@@ -96,22 +96,22 @@ class copy_constructible_equality_comparable
         return ampersand_operator_used();
       }
 #endif
-};
+    };
 
-bool operator==(copy_constructible_equality_comparable,
+    bool operator==(copy_constructible_equality_comparable,
       copy_constructible_equality_comparable)
-{
+    {
       return true;
-}
+    }
 
-bool operator!=(copy_constructible_equality_comparable,
+    bool operator!=(copy_constructible_equality_comparable,
       copy_constructible_equality_comparable)
-{
+    {
       return false;
-}
+    }
 
-class default_assignable
+    class default_assignable
-{
+    {
     public:
       default_assignable(constructor_param const&) {}
 
@@ -131,10 +131,10 @@ class default_assignable
         return ampersand_operator_used();
       }
 #endif
-};
+    };
 
-class assignable
+    class assignable
-{
+    {
     public:
       assignable(constructor_param const&) {}
       assignable(assignable const&) {}
@@ -149,14 +149,14 @@ class assignable
         return ampersand_operator_used();
       }
 #endif
-};
+    };
 
-struct movable_init
+    struct movable_init
-{
+    {
-};
+    };
 
-class movable1
+    class movable1
-{
+    {
       BOOST_MOVABLE_BUT_NOT_COPYABLE(movable1)
 
     public:
@@ -167,11 +167,11 @@ class movable1
       movable1& operator=(BOOST_RV_REF(movable1)) { return *this; }
       ~movable1() {}
       void dummy_member() const {}
-};
+    };
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-class movable2
+    class movable2
-{
+    {
     public:
       movable2(constructor_param const&) {}
       explicit movable2(movable_init) {}
@@ -183,13 +183,13 @@ class movable2
       movable2() {}
       movable2(movable2 const&);
       movable2& operator=(movable2 const&);
-};
+    };
 #else
-typedef movable1 movable2;
+    typedef movable1 movable2;
 #endif
 
-template <class T> class hash
+    template <class T> class hash
-{
+    {
     public:
       hash(constructor_param const&) {}
       hash() {}
@@ -204,10 +204,10 @@ template <class T> class hash
         return ampersand_operator_used();
       }
 #endif
-};
+    };
 
-template <class T> class equal_to
+    template <class T> class equal_to
-{
+    {
     public:
       equal_to(constructor_param const&) {}
       equal_to() {}
@@ -222,13 +222,13 @@ template <class T> class equal_to
         return ampersand_operator_used();
       }
 #endif
-};
+    };
 
-template <class T> class ptr;
+    template <class T> class ptr;
-template <class T> class const_ptr;
+    template <class T> class const_ptr;
 
-struct void_ptr
+    struct void_ptr
-{
+    {
 #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
       template <typename T> friend class ptr;
 
@@ -248,10 +248,10 @@ struct void_ptr
 
       bool operator==(void_ptr const& x) const { return ptr_ == x.ptr_; }
       bool operator!=(void_ptr const& x) const { return ptr_ != x.ptr_; }
-};
+    };
 
-class void_const_ptr
+    class void_const_ptr
-{
+    {
 #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
       template <typename T> friend class const_ptr;
 
@@ -274,10 +274,10 @@ class void_const_ptr
 
       bool operator==(void_const_ptr const& x) const { return ptr_ == x.ptr_; }
       bool operator!=(void_const_ptr const& x) const { return ptr_ != x.ptr_; }
-};
+    };
 
-template <class T> class ptr
+    template <class T> class ptr
-{
+    {
       friend class allocator<T>;
       friend class const_ptr<T>;
       friend struct void_ptr;
@@ -303,7 +303,10 @@ template <class T> class ptr
         return tmp;
       }
       ptr operator+(std::ptrdiff_t s) const { return ptr<T>(ptr_ + s); }
-    friend ptr operator+(std::ptrdiff_t s, ptr p) { return ptr<T>(s + p.ptr_); }
+      friend ptr operator+(std::ptrdiff_t s, ptr p)
+      {
+        return ptr<T>(s + p.ptr_);
+      }
       T& operator[](std::ptrdiff_t s) const { return ptr_[s]; }
       bool operator!() const { return !ptr_; }
 
@@ -323,10 +326,10 @@ template <class T> class ptr
         return ampersand_operator_used();
       }
 #endif
-};
+    };
 
-template <class T> class const_ptr
+    template <class T> class const_ptr
-{
+    {
       friend class allocator<T>;
       friend struct const_void_ptr;
 
@@ -351,7 +354,10 @@ template <class T> class const_ptr
         ++ptr_;
         return tmp;
       }
-    const_ptr operator+(std::ptrdiff_t s) const { return const_ptr(ptr_ + s); }
+      const_ptr operator+(std::ptrdiff_t s) const
+      {
+        return const_ptr(ptr_ + s);
+      }
       friend const_ptr operator+(std::ptrdiff_t s, const_ptr p)
       {
         return ptr<T>(s + p.ptr_);
@@ -372,10 +378,10 @@ template <class T> class const_ptr
         return ampersand_operator_used();
       }
 #endif
-};
+    };
 
-template <class T> class allocator
+    template <class T> class allocator
-{
+    {
     public:
       typedef std::size_t size_type;
       typedef std::ptrdiff_t difference_type;
@@ -410,7 +416,10 @@ template <class T> class allocator
         return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
       }
 
-    void deallocate(pointer p, size_type) { ::operator delete((void*)p.ptr_); }
+      void deallocate(pointer p, size_type)
+      {
+        ::operator delete((void*)p.ptr_);
+      }
 
       void construct(T* p, T const& t) { new ((void*)p) T(t); }
 
@@ -439,10 +448,10 @@ template <class T> class allocator
         return ampersand_operator_used();
       }
 #endif
-};
+    };
 
-template <class T> class allocator<T const>
+    template <class T> class allocator<T const>
-{
+    {
     public:
       typedef std::size_t size_type;
       typedef std::ptrdiff_t difference_type;
@@ -477,7 +486,10 @@ template <class T> class allocator<T const>
         return pointer(static_cast<T const*>(::operator new(n * sizeof(T))));
       }
 
-    void deallocate(pointer p, size_type) { ::operator delete((void*)p.ptr_); }
+      void deallocate(pointer p, size_type)
+      {
+        ::operator delete((void*)p.ptr_);
+      }
 
       void construct(T const* p, T const& t) { new ((void*)p) T(t); }
 
@@ -507,29 +519,29 @@ template <class T> class allocator<T const>
         return ampersand_operator_used();
       }
 #endif
-};
+    };
 
-template <class T>
+    template <class T>
-inline bool operator==(allocator<T> const&, allocator<T> const&)
+    inline bool operator==(allocator<T> const&, allocator<T> const&)
-{
+    {
       return true;
-}
+    }
 
-template <class T>
+    template <class T>
-inline bool operator!=(allocator<T> const&, allocator<T> const&)
+    inline bool operator!=(allocator<T> const&, allocator<T> const&)
-{
+    {
       return false;
-}
+    }
 
-template <class T> void swap(allocator<T>&, allocator<T>&) {}
+    template <class T> void swap(allocator<T>&, allocator<T>&) {}
 
-// C++11 allocator
+    // C++11 allocator
-//
+    //
-// Not a fully minimal C++11 allocator, just what I support. Hopefully will
+    // Not a fully minimal C++11 allocator, just what I support. Hopefully will
-// cut down further in the future.
+    // cut down further in the future.
 
-template <class T> class cxx11_allocator
+    template <class T> class cxx11_allocator
-{
+    {
     public:
       typedef T value_type;
       // template <class U> struct rebind { typedef cxx11_allocator<U> other; };
@@ -566,39 +578,39 @@ template <class T> class cxx11_allocator
       void destroy(T* p) { p->~T(); }
 
       std::size_t max_size() const { return 1000u; }
-};
+    };
 
-template <class T>
+    template <class T>
-inline bool operator==(cxx11_allocator<T> const&, cxx11_allocator<T> const&)
+    inline bool operator==(cxx11_allocator<T> const&, cxx11_allocator<T> const&)
-{
+    {
       return true;
-}
+    }
 
-template <class T>
+    template <class T>
-inline bool operator!=(cxx11_allocator<T> const&, cxx11_allocator<T> const&)
+    inline bool operator!=(cxx11_allocator<T> const&, cxx11_allocator<T> const&)
-{
+    {
       return false;
-}
+    }
 
-template <class T> void swap(cxx11_allocator<T>&, cxx11_allocator<T>&) {}
+    template <class T> void swap(cxx11_allocator<T>&, cxx11_allocator<T>&) {}
-}
+  }
 }
 
 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
 namespace boost {
 #else
 namespace test {
-namespace minimal {
+  namespace minimal {
 #endif
-std::size_t hash_value(test::minimal::copy_constructible_equality_comparable)
+  std::size_t hash_value(test::minimal::copy_constructible_equality_comparable)
-{
+  {
     return 1;
-}
+  }
 #if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
 }
 }
 #else
-}
+  }
 #endif
 
 #if defined(BOOST_MSVC)

test/objects/test.hpp

@@ -14,25 +14,25 @@
 #include <cstddef>
 
 namespace test {
-// Note that the default hash function will work for any equal_to (but not
+  // Note that the default hash function will work for any equal_to (but not
-// very well).
+  // very well).
-class object;
+  class object;
-class movable;
+  class movable;
-class implicitly_convertible;
+  class implicitly_convertible;
-class hash;
+  class hash;
-class less;
+  class less;
-class equal_to;
+  class equal_to;
-template <class T> class allocator1;
+  template <class T> class allocator1;
-template <class T> class allocator2;
+  template <class T> class allocator2;
-object generate(object const*, random_generator);
+  object generate(object const*, random_generator);
-movable generate(movable const*, random_generator);
+  movable generate(movable const*, random_generator);
-implicitly_convertible generate(
+  implicitly_convertible generate(
     implicitly_convertible const*, random_generator);
 
-inline void ignore_variable(void const*) {}
+  inline void ignore_variable(void const*) {}
 
-class object : private counted_object
+  class object : private counted_object
-{
+  {
     friend class hash;
     friend class equal_to;
     friend class less;
@@ -73,10 +73,10 @@ class object : private counted_object
     {
       return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
     }
-};
+  };
 
-class movable : private counted_object
+  class movable : private counted_object
-{
+  {
     friend class hash;
     friend class equal_to;
     friend class less;
@@ -153,10 +153,10 @@ class movable : private counted_object
     {
       return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
     }
-};
+  };
 
-class implicitly_convertible : private counted_object
+  class implicitly_convertible : private counted_object
-{
+  {
     int tag1_, tag2_;
 
   public:
@@ -181,11 +181,11 @@ class implicitly_convertible : private counted_object
     {
       return out << "(" << o.tag1_ << "," << o.tag2_ << ")";
     }
-};
+  };
 
-// Note: This is a deliberately bad hash function.
+  // Note: This is a deliberately bad hash function.
-class hash
+  class hash
-{
+  {
     int type_;
 
   public:
@@ -248,14 +248,14 @@ class hash
     {
       return x1.type_ != x2.type_;
     }
-};
+  };
 
-std::size_t hash_value(test::object const& x) { return hash()(x); }
+  std::size_t hash_value(test::object const& x) { return hash()(x); }
 
-std::size_t hash_value(test::movable const& x) { return hash()(x); }
+  std::size_t hash_value(test::movable const& x) { return hash()(x); }
 
-class less
+  class less
-{
+  {
     int type_;
 
   public:
@@ -291,10 +291,10 @@ class less
     {
       return x1.type_ == x2.type_;
     }
-};
+  };
 
-class equal_to
+  class equal_to
-{
+  {
     int type_;
 
   public:
@@ -337,13 +337,13 @@ class equal_to
     }
 
     friend less create_compare(equal_to x) { return less(x.type_); }
-};
+  };
 
-// allocator1 only has the old fashioned 'construct' method and has
+  // allocator1 only has the old fashioned 'construct' method and has
-// a few less typedefs. allocator2 uses a custom pointer class.
+  // a few less typedefs. allocator2 uses a custom pointer class.
 
-template <class T> class allocator1
+  template <class T> class allocator1
-{
+  {
   public:
     int tag_;
 
@@ -434,13 +434,13 @@ template <class T> class allocator1
       is_propagate_on_assign = false,
       is_propagate_on_move = false
     };
-};
+  };
 
-template <class T> class ptr;
+  template <class T> class ptr;
-template <class T> class const_ptr;
+  template <class T> class const_ptr;
 
-struct void_ptr
+  struct void_ptr
-{
+  {
 #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
     template <typename T> friend class ptr;
 
@@ -460,10 +460,10 @@ struct void_ptr
 
     bool operator==(void_ptr const& x) const { return ptr_ == x.ptr_; }
     bool operator!=(void_ptr const& x) const { return ptr_ != x.ptr_; }
-};
+  };
 
-class void_const_ptr
+  class void_const_ptr
-{
+  {
 #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
     template <typename T> friend class const_ptr;
 
@@ -486,10 +486,10 @@ class void_const_ptr
 
     bool operator==(void_const_ptr const& x) const { return ptr_ == x.ptr_; }
     bool operator!=(void_const_ptr const& x) const { return ptr_ != x.ptr_; }
-};
+  };
 
-template <class T> class ptr
+  template <class T> class ptr
-{
+  {
     friend class allocator2<T>;
     friend class const_ptr<T>;
     friend struct void_ptr;
@@ -529,10 +529,10 @@ template <class T> class ptr
     bool operator>(ptr const& x) const { return ptr_ > x.ptr_; }
     bool operator<=(ptr const& x) const { return ptr_ <= x.ptr_; }
     bool operator>=(ptr const& x) const { return ptr_ >= x.ptr_; }
-};
+  };
 
-template <class T> class const_ptr
+  template <class T> class const_ptr
-{
+  {
     friend class allocator2<T>;
     friend struct const_void_ptr;
 
@@ -572,10 +572,10 @@ template <class T> class const_ptr
     bool operator>(const_ptr const& x) const { return ptr_ > x.ptr_; }
     bool operator<=(const_ptr const& x) const { return ptr_ <= x.ptr_; }
     bool operator>=(const_ptr const& x) const { return ptr_ >= x.ptr_; }
-};
+  };
 
-template <class T> class allocator2
+  template <class T> class allocator2
-{
+  {
 #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
   public:
 #else
@@ -676,21 +676,21 @@ template <class T> class allocator2
       is_propagate_on_assign = false,
       is_propagate_on_move = false
     };
-};
+  };
 
-template <class T>
+  template <class T>
-bool equivalent_impl(
+  bool equivalent_impl(
     allocator1<T> const& x, allocator1<T> const& y, test::derived_type)
-{
+  {
     return x == y;
-}
+  }
 
-template <class T>
+  template <class T>
-bool equivalent_impl(
+  bool equivalent_impl(
     allocator2<T> const& x, allocator2<T> const& y, test::derived_type)
-{
+  {
     return x == y;
-}
+  }
 }
 
 #endif

test/unordered/allocator_traits.cpp

@@ -115,8 +115,7 @@ void test_empty_allocator()
   BOOST_STATIC_ASSERT((boost::is_same<traits::size_type,
     std::make_unsigned<std::ptrdiff_t>::type>::value));
 #else
-    BOOST_STATIC_ASSERT(
+  BOOST_STATIC_ASSERT((boost::is_same<traits::size_type, std::size_t>::value));
-        (boost::is_same<traits::size_type, std::size_t>::value));
 #endif
   BOOST_STATIC_ASSERT(
     (boost::is_same<traits::difference_type, std::ptrdiff_t>::value));
@@ -156,8 +155,7 @@ void test_allocator1()
   BOOST_STATIC_ASSERT((boost::is_same<traits::size_type,
     std::make_unsigned<std::ptrdiff_t>::type>::value));
 #else
-    BOOST_STATIC_ASSERT(
+  BOOST_STATIC_ASSERT((boost::is_same<traits::size_type, std::size_t>::value));
-        (boost::is_same<traits::size_type, std::size_t>::value));
 #endif
   BOOST_STATIC_ASSERT(
     (boost::is_same<traits::difference_type, std::ptrdiff_t>::value));
@@ -200,8 +198,7 @@ void test_allocator2()
 {
   typedef allocator2<int> allocator;
   typedef boost::unordered::detail::allocator_traits<allocator> traits;
-    BOOST_STATIC_ASSERT(
+  BOOST_STATIC_ASSERT((boost::is_same<traits::size_type, std::size_t>::value));
-        (boost::is_same<traits::size_type, std::size_t>::value));
   BOOST_STATIC_ASSERT(
     (boost::is_same<traits::difference_type, std::ptrdiff_t>::value));
   BOOST_STATIC_ASSERT((boost::is_same<traits::pointer, int*>::value));

test/unordered/assign_tests.cpp

@@ -23,10 +23,10 @@
 
 namespace assign_tests {
 
-test::seed_t initialize_seed(96785);
+  test::seed_t initialize_seed(96785);
 
-template <class T> void assign_tests1(T*, test::random_generator generator)
+  template <class T> void assign_tests1(T*, test::random_generator generator)
-{
+  {
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::key_equal eq;
 
@@ -64,10 +64,10 @@ template <class T> void assign_tests1(T*, test::random_generator generator)
       BOOST_TEST(y.max_load_factor() == mlf);
       BOOST_TEST(y.load_factor() <= y.max_load_factor());
     }
-}
+  }
 
-template <class T> void assign_tests2(T*, test::random_generator generator)
+  template <class T> void assign_tests2(T*, test::random_generator generator)
-{
+  {
     BOOST_DEDUCED_TYPENAME T::hasher hf1(1);
     BOOST_DEDUCED_TYPENAME T::hasher hf2(2);
     BOOST_DEDUCED_TYPENAME T::key_equal eq1(1);
@@ -191,65 +191,65 @@ template <class T> void assign_tests2(T*, test::random_generator generator)
       test::check_container(x2, v1);
       BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
     }
-}
+  }
 
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     std::allocator<test::object> >* test_map_std_alloc;
 
-boost::unordered_set<test::object, test::hash, test::equal_to,
+  boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
-boost::unordered_multiset<test::object, test::hash, test::equal_to,
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, test::allocator1<test::object> >* test_multimap;
 
-boost::unordered_set<test::object, test::hash, test::equal_to,
+  boost::unordered_set<test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::propagate_assign> >*
     test_set_prop_assign;
-boost::unordered_multiset<test::object, test::hash, test::equal_to,
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::propagate_assign> >*
     test_multiset_prop_assign;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::propagate_assign> >*
     test_map_prop_assign;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to,
     test::cxx11_allocator<test::object, test::propagate_assign> >*
     test_multimap_prop_assign;
 
-boost::unordered_set<test::object, test::hash, test::equal_to,
+  boost::unordered_set<test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::no_propagate_assign> >*
     test_set_no_prop_assign;
-boost::unordered_multiset<test::object, test::hash, test::equal_to,
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::no_propagate_assign> >*
     test_multiset_no_prop_assign;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::no_propagate_assign> >*
     test_map_no_prop_assign;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to,
     test::cxx11_allocator<test::object, test::no_propagate_assign> >*
     test_multimap_no_prop_assign;
 
-using test::default_generator;
+  using test::default_generator;
-using test::generate_collisions;
+  using test::generate_collisions;
-using test::limited_range;
+  using test::limited_range;
 
-template <typename T> bool is_propagate(T*)
+  template <typename T> bool is_propagate(T*)
-{
+  {
     return T::allocator_type::is_propagate_on_assign;
-}
+  }
 
-UNORDERED_AUTO_TEST(check_traits)
+  UNORDERED_AUTO_TEST(check_traits)
-{
+  {
     BOOST_TEST(!is_propagate(test_set));
     BOOST_TEST(is_propagate(test_set_prop_assign));
     BOOST_TEST(!is_propagate(test_set_no_prop_assign));
-}
+  }
 
-UNORDERED_TEST(assign_tests1,
+  UNORDERED_TEST(assign_tests1,
     ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap)(
       test_set_prop_assign)(test_multiset_prop_assign)(test_map_prop_assign)(
       test_multimap_prop_assign)(test_set_no_prop_assign)(
@@ -257,7 +257,7 @@ UNORDERED_TEST(assign_tests1,
       test_multimap_no_prop_assign))(
                    (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(
+  UNORDERED_TEST(
     assign_tests2, ((test_set)(test_multiset)(test_map)(test_multimap)(
                      test_set_prop_assign)(test_multiset_prop_assign)(
                      test_map_prop_assign)(test_multimap_prop_assign)(
@@ -267,8 +267,8 @@ UNORDERED_TEST(
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 
-UNORDERED_AUTO_TEST(assign_default_initializer_list)
+  UNORDERED_AUTO_TEST(assign_default_initializer_list)
-{
+  {
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer List Tests\n";
     std::initializer_list<std::pair<int const, int> > init;
     boost::unordered_map<int, int> x1;
@@ -277,13 +277,13 @@ UNORDERED_AUTO_TEST(assign_default_initializer_list)
     BOOST_TEST(!x1.empty());
     x1 = init;
     BOOST_TEST(x1.empty());
-}
+  }
 
 #endif
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-UNORDERED_AUTO_TEST(assign_initializer_list)
+  UNORDERED_AUTO_TEST(assign_initializer_list)
-{
+  {
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer List Tests\n";
 
     boost::unordered_set<int> x;
@@ -292,7 +292,7 @@ UNORDERED_AUTO_TEST(assign_initializer_list)
     x = {1, 2, -10};
     BOOST_TEST(x.find(10) == x.end());
     BOOST_TEST(x.find(-10) != x.end());
-}
+  }
 
 #endif
 }

test/unordered/at_tests.cpp

@@ -14,8 +14,8 @@
 
 namespace at_tests {
 
-UNORDERED_AUTO_TEST(at_tests)
+  UNORDERED_AUTO_TEST(at_tests)
-{
+  {
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Create Map" << std::endl;
 
     boost::unordered_map<std::string, int> x;
@@ -62,7 +62,7 @@ UNORDERED_AUTO_TEST(at_tests)
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Finished" << std::endl;
-}
+  }
 }
 
 RUN_TESTS()

test/unordered/bucket_tests.cpp

@@ -23,10 +23,10 @@
 
 namespace bucket_tests {
 
-test::seed_t initialize_seed(54635);
+  test::seed_t initialize_seed(54635);
 
-template <class X> void tests(X*, test::random_generator generator)
+  template <class X> void tests(X*, test::random_generator generator)
-{
+  {
     test::check_instances check_;
 
     typedef BOOST_DEDUCED_TYPENAME X::size_type size_type;
@@ -51,8 +51,7 @@ template <class X> void tests(X*, test::random_generator generator)
       if (bucket < x.bucket_count()) {
         // lit? lend?? I need a new naming scheme.
         const_local_iterator lit = x.begin(bucket), lend = x.end(bucket);
-            while (lit != lend &&
+        while (lit != lend && test::get_key<X>(*it) != test::get_key<X>(*lit)) {
-                   test::get_key<X>(*it) != test::get_key<X>(*lit)) {
           ++lit;
         }
         BOOST_TEST(lit != lend);
@@ -62,35 +61,35 @@ template <class X> void tests(X*, test::random_generator generator)
     for (size_type i = 0; i < x.bucket_count(); ++i) {
       BOOST_TEST(x.bucket_size(i) ==
                  static_cast<size_type>(std::distance(x.begin(i), x.end(i))));
-        BOOST_TEST(x.bucket_size(i) == static_cast<size_type>(std::distance(
+      BOOST_TEST(x.bucket_size(i) ==
-                                           x.cbegin(i), x.cend(i))));
+                 static_cast<size_type>(std::distance(x.cbegin(i), x.cend(i))));
       X const& x_ref = x;
       BOOST_TEST(x.bucket_size(i) == static_cast<size_type>(std::distance(
                                        x_ref.begin(i), x_ref.end(i))));
       BOOST_TEST(x.bucket_size(i) == static_cast<size_type>(std::distance(
                                        x_ref.cbegin(i), x_ref.cend(i))));
     }
-}
+  }
 
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, std::allocator<test::object> >* test_multimap_std_alloc;
 
-boost::unordered_set<test::object, test::hash, test::equal_to,
+  boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_set;
-boost::unordered_multiset<test::object, test::hash, test::equal_to,
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, test::allocator2<test::object> >* test_multimap;
 
-using test::default_generator;
+  using test::default_generator;
-using test::generate_collisions;
+  using test::generate_collisions;
-using test::limited_range;
+  using test::limited_range;
 
-UNORDERED_TEST(tests, ((test_multimap_std_alloc)(test_set)(test_multiset)(
+  UNORDERED_TEST(tests,
-                          test_map)(test_multimap))((default_generator)(
+    ((test_multimap_std_alloc)(test_set)(test_multiset)(test_map)(
-                          generate_collisions)(limited_range)))
+      test_multimap))((default_generator)(generate_collisions)(limited_range)))
 }
 
 RUN_TESTS()

test/unordered/compile_map.cpp

@@ -26,8 +26,8 @@ INSTANTIATE(map)<int, int, boost::hash<int>, std::equal_to<int>,
 INSTANTIATE(multimap)<int const, int const, boost::hash<int>,
   std::equal_to<int>, test::minimal::allocator<int> >;
 
-INSTANTIATE(map)<test::minimal::assignable const,
+INSTANTIATE(
-    test::minimal::default_assignable const,
+  map)<test::minimal::assignable const, test::minimal::default_assignable const,
   test::minimal::hash<test::minimal::assignable>,
   test::minimal::equal_to<test::minimal::assignable>,
   test::minimal::allocator<int> >;
@@ -40,8 +40,7 @@ UNORDERED_AUTO_TEST(test0)
 {
   test::minimal::constructor_param x;
 
-    typedef std::pair<test::minimal::assignable const,
+  typedef std::pair<test::minimal::assignable const, test::minimal::assignable>
-        test::minimal::assignable>
     value_type;
   value_type value(x, x);
 
@@ -72,8 +71,7 @@ UNORDERED_AUTO_TEST(test0)
     int_multimap2;
 
   boost::unordered_multimap<test::minimal::assignable,
-        test::minimal::assignable,
+    test::minimal::assignable, test::minimal::hash<test::minimal::assignable>,
-        test::minimal::hash<test::minimal::assignable>,
     test::minimal::equal_to<test::minimal::assignable>,
     test::minimal::allocator<value_type> >
     multimap;
@@ -85,8 +83,7 @@ UNORDERED_AUTO_TEST(test0)
 
 UNORDERED_AUTO_TEST(equality_tests)
 {
-    typedef std::pair<
+  typedef std::pair<test::minimal::copy_constructible_equality_comparable const,
-        test::minimal::copy_constructible_equality_comparable const,
     test::minimal::copy_constructible_equality_comparable>
     value_type;
 
@@ -96,11 +93,9 @@ UNORDERED_AUTO_TEST(equality_tests)
     test::minimal::cxx11_allocator<std::pair<int const, int> > >
     int_map2;
 
-    boost::unordered_map<
+  boost::unordered_map<test::minimal::copy_constructible_equality_comparable,
     test::minimal::copy_constructible_equality_comparable,
-        test::minimal::copy_constructible_equality_comparable,
+    test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
-        test::minimal::hash<
-            test::minimal::copy_constructible_equality_comparable>,
     test::minimal::equal_to<
                          test::minimal::copy_constructible_equality_comparable>,
     test::minimal::allocator<value_type> >
@@ -119,8 +114,7 @@ UNORDERED_AUTO_TEST(equality_tests)
   boost::unordered_multimap<
     test::minimal::copy_constructible_equality_comparable,
     test::minimal::copy_constructible_equality_comparable,
-        test::minimal::hash<
+    test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
-            test::minimal::copy_constructible_equality_comparable>,
     test::minimal::equal_to<
       test::minimal::copy_constructible_equality_comparable>,
     test::minimal::allocator<value_type> >
@@ -182,8 +176,7 @@ UNORDERED_AUTO_TEST(test2)
   test::minimal::hash<test::minimal::assignable> hash(x);
   test::minimal::equal_to<test::minimal::assignable> equal_to(x);
 
-    typedef std::pair<test::minimal::assignable const,
+  typedef std::pair<test::minimal::assignable const, test::minimal::assignable>
-        test::minimal::assignable>
     map_value_type;
   map_value_type map_value(assignable, assignable);
 
@@ -214,8 +207,7 @@ UNORDERED_AUTO_TEST(test2)
   BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
 
   boost::unordered_multimap<test::minimal::assignable,
-        test::minimal::assignable,
+    test::minimal::assignable, test::minimal::hash<test::minimal::assignable>,
-        test::minimal::hash<test::minimal::assignable>,
     test::minimal::equal_to<test::minimal::assignable>,
     test::minimal::allocator<map_value_type> >
     multimap;

test/unordered/compile_set.cpp

@@ -88,10 +88,8 @@ UNORDERED_AUTO_TEST(equality_tests)
     test::minimal::cxx11_allocator<int> >
     int_set2;
 
-    boost::unordered_set<
+  boost::unordered_set<test::minimal::copy_constructible_equality_comparable,
-        test::minimal::copy_constructible_equality_comparable,
+    test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
-        test::minimal::hash<
-            test::minimal::copy_constructible_equality_comparable>,
     test::minimal::equal_to<
                          test::minimal::copy_constructible_equality_comparable>,
     test::minimal::allocator<value_type> >
@@ -109,8 +107,7 @@ UNORDERED_AUTO_TEST(equality_tests)
 
   boost::unordered_multiset<
     test::minimal::copy_constructible_equality_comparable,
-        test::minimal::hash<
+    test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
-            test::minimal::copy_constructible_equality_comparable>,
     test::minimal::equal_to<
       test::minimal::copy_constructible_equality_comparable>,
     test::minimal::allocator<value_type> >

test/unordered/compile_tests.hpp

@@ -87,8 +87,7 @@ template <class X, class T> void container_test(X& r, T const&)
 
   boost::function_requires<boost::InputIteratorConcept<iterator> >();
   BOOST_STATIC_ASSERT((boost::is_same<T, iterator_value_type>::value));
-    BOOST_STATIC_ASSERT(
+  BOOST_STATIC_ASSERT((boost::is_convertible<iterator, const_iterator>::value));
-        (boost::is_convertible<iterator, const_iterator>::value));
 
   // const_iterator
 
@@ -106,8 +105,8 @@ template <class X, class T> void container_test(X& r, T const&)
   BOOST_STATIC_ASSERT(std::numeric_limits<difference_type>::is_integer);
   BOOST_STATIC_ASSERT(
     (boost::is_same<difference_type, iterator_difference_type>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<difference_type,
+  BOOST_STATIC_ASSERT(
-        const_iterator_difference_type>::value));
+    (boost::is_same<difference_type, const_iterator_difference_type>::value));
 
   // size_type
 
@@ -279,8 +278,8 @@ template <class X, class Key> void unordered_set_test(X& r, Key const&)
     (boost::is_same<value_type const*, const_iterator_pointer>::value));
   BOOST_STATIC_ASSERT(
     (boost::is_same<value_type const*, local_iterator_pointer>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<value_type const*,
+  BOOST_STATIC_ASSERT(
-        const_local_iterator_pointer>::value));
+    (boost::is_same<value_type const*, const_local_iterator_pointer>::value));
 
   typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
   typedef BOOST_DEDUCED_TYPENAME node_type::value_type node_value_type;
@@ -324,8 +323,8 @@ void unordered_map_test(X& r, Key const& k, T const& v)
     (boost::is_same<value_type const*, const_iterator_pointer>::value));
   BOOST_STATIC_ASSERT(
     (boost::is_same<value_type*, local_iterator_pointer>::value));
-    BOOST_STATIC_ASSERT((boost::is_same<value_type const*,
+  BOOST_STATIC_ASSERT(
-        const_local_iterator_pointer>::value));
+    (boost::is_same<value_type const*, const_local_iterator_pointer>::value));
 
   typedef BOOST_DEDUCED_TYPENAME X::node_type node_type;
   typedef BOOST_DEDUCED_TYPENAME node_type::key_type node_key_type;
@@ -480,8 +479,8 @@ void unordered_test(X& x, Key& k, Hash& hf, Pred& eq)
   typedef BOOST_DEDUCED_TYPENAME X::local_iterator local_iterator;
   typedef BOOST_DEDUCED_TYPENAME X::const_local_iterator const_local_iterator;
 
-    typedef BOOST_DEDUCED_TYPENAME
+  typedef BOOST_DEDUCED_TYPENAME boost::BOOST_ITERATOR_CATEGORY<iterator>::type
-        boost::BOOST_ITERATOR_CATEGORY<iterator>::type iterator_category;
+    iterator_category;
   typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<iterator>::type
     iterator_difference;
   typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<iterator>::type
@@ -491,21 +490,21 @@ void unordered_test(X& x, Key& k, Hash& hf, Pred& eq)
 
   typedef BOOST_DEDUCED_TYPENAME boost::BOOST_ITERATOR_CATEGORY<
     local_iterator>::type local_iterator_category;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<
+  typedef BOOST_DEDUCED_TYPENAME
-        local_iterator>::type local_iterator_difference;
+    boost::iterator_difference<local_iterator>::type local_iterator_difference;
   typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<local_iterator>::type
     local_iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<local_iterator>::type
-        local_iterator>::type local_iterator_reference;
+    local_iterator_reference;
 
   typedef BOOST_DEDUCED_TYPENAME boost::BOOST_ITERATOR_CATEGORY<
     const_iterator>::type const_iterator_category;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_difference<
+  typedef BOOST_DEDUCED_TYPENAME
-        const_iterator>::type const_iterator_difference;
+    boost::iterator_difference<const_iterator>::type const_iterator_difference;
   typedef BOOST_DEDUCED_TYPENAME boost::iterator_pointer<const_iterator>::type
     const_iterator_pointer;
-    typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<
+  typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<const_iterator>::type
-        const_iterator>::type const_iterator_reference;
+    const_iterator_reference;
 
   typedef BOOST_DEDUCED_TYPENAME boost::BOOST_ITERATOR_CATEGORY<
     const_local_iterator>::type const_local_iterator_category;
@@ -530,8 +529,8 @@ void unordered_test(X& x, Key& k, Hash& hf, Pred& eq)
   boost::function_requires<boost::InputIteratorConcept<local_iterator> >();
   BOOST_STATIC_ASSERT(
     (boost::is_same<local_iterator_category, iterator_category>::value));
-    BOOST_STATIC_ASSERT((
+  BOOST_STATIC_ASSERT(
-        boost::is_same<local_iterator_difference, iterator_difference>::value));
+    (boost::is_same<local_iterator_difference, iterator_difference>::value));
   BOOST_STATIC_ASSERT(
     (boost::is_same<local_iterator_pointer, iterator_pointer>::value));
   BOOST_STATIC_ASSERT(
@@ -794,8 +793,7 @@ void unordered_movable_test(X& x, Key& k, T& /* t */, Hash& hf, Pred& eq)
   T v2(v);
   a.insert(boost::move(v2));
   T v3(v);
-    test::check_return_type<iterator>::equals(
+  test::check_return_type<iterator>::equals(a.emplace_hint(q, boost::move(v3)));
-        a.emplace_hint(q, boost::move(v3)));
   T v4(v);
   test::check_return_type<iterator>::equals(a.insert(q, boost::move(v4)));
 

test/unordered/constructor_tests.cpp

@@ -20,10 +20,11 @@
 
 namespace constructor_tests {
 
-test::seed_t initialize_seed(356730);
+  test::seed_t initialize_seed(356730);
 
-template <class T> void constructor_tests1(T*, test::random_generator generator)
+  template <class T>
-{
+  void constructor_tests1(T*, test::random_generator generator)
+  {
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::key_equal eq;
     BOOST_DEDUCED_TYPENAME T::allocator_type al;
@@ -170,11 +171,11 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
       BOOST_TEST(test::equivalent(x.get_allocator(), al));
       test::check_equivalent_keys(x);
     }
-}
+  }
 
-template <class T>
+  template <class T>
-void constructor_tests2(T*, test::random_generator const& generator)
+  void constructor_tests2(T*, test::random_generator const& generator)
-{
+  {
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::hasher hf1(1);
     BOOST_DEDUCED_TYPENAME T::hasher hf2(2);
@@ -273,9 +274,10 @@ void constructor_tests2(T*, test::random_generator const& generator)
     {
       test::check_instances check_;
       test::random_values<T> v(100, generator);
-        BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
+      BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator v_begin =
-            v_begin = v.begin(),
+                                                                      v.begin(),
-            v_end = v.end();
+                                                                    v_end =
+                                                                      v.end();
       T x(test::input_iterator(v_begin), test::input_iterator(v_end), 0, hf1,
         eq1);
       BOOST_DEDUCED_TYPENAME T::const_iterator x_begin = x.begin(),
@@ -292,10 +294,10 @@ void constructor_tests2(T*, test::random_generator const& generator)
     {
       test::check_instances check_;
       test::random_values<T> v(100, generator);
-        T x(test::copy_iterator(v.begin()), test::copy_iterator(v.end()), 0,
+      T x(test::copy_iterator(v.begin()), test::copy_iterator(v.end()), 0, hf1,
-            hf1, eq1);
+        eq1);
-        T y(test::copy_iterator(x.begin()), test::copy_iterator(x.end()), 0,
+      T y(test::copy_iterator(x.begin()), test::copy_iterator(x.end()), 0, hf2,
-            hf2, eq2);
+        eq2);
       test::check_container(x, v);
       test::check_container(y, x);
       test::check_equivalent_keys(x);
@@ -379,11 +381,11 @@ void constructor_tests2(T*, test::random_generator const& generator)
       BOOST_TEST(test::equivalent(x.get_allocator(), al1));
     }
 #endif
-}
+  }
 
-template <class T>
+  template <class T>
-void map_constructor_test(T*, test::random_generator const& generator)
+  void map_constructor_test(T*, test::random_generator const& generator)
-{
+  {
     typedef test::list<std::pair<BOOST_DEDUCED_TYPENAME T::key_type,
       BOOST_DEDUCED_TYPENAME T::mapped_type> >
       list;
@@ -393,55 +395,55 @@ void map_constructor_test(T*, test::random_generator const& generator)
 
     test::check_container(x, v);
     test::check_equivalent_keys(x);
-}
+  }
 
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     std::allocator<test::object> >* test_map_std_alloc;
 
-boost::unordered_set<test::object, test::hash, test::equal_to,
+  boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
-boost::unordered_multiset<test::object, test::hash, test::equal_to,
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, test::allocator1<test::object> >* test_multimap;
 
-using test::default_generator;
+  using test::default_generator;
-using test::generate_collisions;
+  using test::generate_collisions;
-using test::limited_range;
+  using test::limited_range;
 
-UNORDERED_TEST(constructor_tests1,
+  UNORDERED_TEST(constructor_tests1,
     ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap))(
                    (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(constructor_tests2,
+  UNORDERED_TEST(constructor_tests2,
     ((test_set)(test_multiset)(test_map)(test_multimap))(
                    (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(map_constructor_test,
+  UNORDERED_TEST(map_constructor_test,
     ((test_map_std_alloc)(test_map)(test_multimap))(
                    (default_generator)(generate_collisions)(limited_range)))
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 
-UNORDERED_AUTO_TEST(test_default_initializer_list)
+  UNORDERED_AUTO_TEST(test_default_initializer_list)
-{
+  {
     std::initializer_list<int> init;
     boost::unordered_set<int> x1 = init;
     BOOST_TEST(x1.empty());
-}
+  }
 
 #endif
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 
-UNORDERED_AUTO_TEST(test_initializer_list)
+  UNORDERED_AUTO_TEST(test_initializer_list)
-{
+  {
     boost::unordered_set<int> x1 = {2, 10, 45, -5};
     BOOST_TEST(x1.find(10) != x1.end());
     BOOST_TEST(x1.find(46) == x1.end());
-}
+  }
 
 #endif
 }

test/unordered/copy_tests.cpp

@@ -22,9 +22,9 @@ test::seed_t initialize_seed(9063);
 
 namespace copy_tests {
 
-template <class T>
+  template <class T>
-void copy_construct_tests1(T*, test::random_generator const& generator)
+  void copy_construct_tests1(T*, test::random_generator const& generator)
-{
+  {
     typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
 
     BOOST_DEDUCED_TYPENAME T::hasher hf;
@@ -79,11 +79,11 @@ void copy_construct_tests1(T*, test::random_generator const& generator)
                  (allocator_type::is_select_on_copy));
       test::check_equivalent_keys(y);
     }
-}
+  }
 
-template <class T>
+  template <class T>
-void copy_construct_tests2(T*, test::random_generator const& generator)
+  void copy_construct_tests2(T*, test::random_generator const& generator)
-{
+  {
     BOOST_DEDUCED_TYPENAME T::hasher hf(1);
     BOOST_DEDUCED_TYPENAME T::key_equal eq(1);
     BOOST_DEDUCED_TYPENAME T::allocator_type al(1);
@@ -148,48 +148,48 @@ void copy_construct_tests2(T*, test::random_generator const& generator)
       BOOST_TEST(test::selected_count(y.get_allocator()) == 0);
       BOOST_TEST(test::equivalent(y.get_allocator(), al2));
     }
-}
+  }
 
-boost::unordered_set<test::object, test::hash, test::equal_to,
+  boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
-boost::unordered_multiset<test::object, test::hash, test::equal_to,
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, test::allocator2<test::object> >* test_multimap;
 
-boost::unordered_set<test::object, test::hash, test::equal_to,
+  boost::unordered_set<test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::select_copy> >*
     test_set_select_copy;
-boost::unordered_multiset<test::object, test::hash, test::equal_to,
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::select_copy> >*
     test_multiset_select_copy;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::select_copy> >*
     test_map_select_copy;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, test::cxx11_allocator<test::object, test::select_copy> >*
     test_multimap_select_copy;
 
-boost::unordered_set<test::object, test::hash, test::equal_to,
+  boost::unordered_set<test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::no_select_copy> >*
     test_set_no_select_copy;
-boost::unordered_multiset<test::object, test::hash, test::equal_to,
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::no_select_copy> >*
     test_multiset_no_select_copy;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::no_select_copy> >*
     test_map_no_select_copy;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, test::cxx11_allocator<test::object, test::no_select_copy> >*
     test_multimap_no_select_copy;
 
-using test::default_generator;
+  using test::default_generator;
-using test::generate_collisions;
+  using test::generate_collisions;
-using test::limited_range;
+  using test::limited_range;
 
-UNORDERED_TEST(copy_construct_tests1,
+  UNORDERED_TEST(copy_construct_tests1,
     ((test_set)(test_multiset)(test_map)(test_multimap)(test_set_select_copy)(
       test_multiset_select_copy)(test_map_select_copy)(
       test_multimap_select_copy)(test_set_no_select_copy)(
@@ -197,7 +197,7 @@ UNORDERED_TEST(copy_construct_tests1,
       test_multimap_no_select_copy))(
                    (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(copy_construct_tests2,
+  UNORDERED_TEST(copy_construct_tests2,
     ((test_set)(test_multiset)(test_map)(test_multimap)(test_set_select_copy)(
       test_multiset_select_copy)(test_map_select_copy)(
       test_multimap_select_copy)(test_set_no_select_copy)(

test/unordered/emplace_tests.cpp

@@ -19,9 +19,9 @@
 // arguments.
 
 namespace emplace_tests {
-// Constructible with 2 to 10 arguments
+  // Constructible with 2 to 10 arguments
-struct emplace_value : private test::counted_object
+  struct emplace_value : private test::counted_object
-{
+  {
     typedef int A0;
     typedef std::string A1;
     typedef char A2;
@@ -165,10 +165,10 @@ struct emplace_value : private test::counted_object
   private:
     emplace_value();
     emplace_value(emplace_value const&);
-};
+  };
 
-UNORDERED_AUTO_TEST(emplace_set)
+  UNORDERED_AUTO_TEST(emplace_set)
-{
+  {
     test::check_instances check_;
 
     typedef boost::unordered_set<emplace_value, boost::hash<emplace_value> >
@@ -233,10 +233,10 @@ UNORDERED_AUTO_TEST(emplace_set)
     BOOST_TEST_EQ(check_.instances(), 8);
     BOOST_TEST_EQ(check_.constructions(), 9);
 
-    BOOST_TEST(r1.first ==
+    BOOST_TEST(
-               x.emplace_hint(r1.first, 10, "", 'a', 4, 5, 6, 7, 8, 9, 10));
+      r1.first == x.emplace_hint(r1.first, 10, "", 'a', 4, 5, 6, 7, 8, 9, 10));
-    BOOST_TEST(r1.first ==
+    BOOST_TEST(
-               x.emplace_hint(r2.first, 10, "", 'a', 4, 5, 6, 7, 8, 9, 10));
+      r1.first == x.emplace_hint(r2.first, 10, "", 'a', 4, 5, 6, 7, 8, 9, 10));
     BOOST_TEST(
       r1.first == x.emplace_hint(x.end(), 10, "", 'a', 4, 5, 6, 7, 8, 9, 10));
     BOOST_TEST_EQ(check_.instances(), 8);
@@ -247,10 +247,10 @@ UNORDERED_AUTO_TEST(emplace_set)
     BOOST_TEST(x.count(v2) == 1);
     BOOST_TEST(x.count(v3) == 1);
     BOOST_TEST(x.count(v4) == 1);
-}
+  }
 
-UNORDERED_AUTO_TEST(emplace_multiset)
+  UNORDERED_AUTO_TEST(emplace_multiset)
-{
+  {
     test::check_instances check_;
 
     typedef boost::unordered_multiset<emplace_value,
@@ -326,10 +326,10 @@ UNORDERED_AUTO_TEST(emplace_multiset)
     BOOST_TEST_EQ(x.count(v1), 1u);
     BOOST_TEST_EQ(x.count(v2), 2u);
     BOOST_TEST_EQ(x.count(v3), 2u);
-}
+  }
 
-UNORDERED_AUTO_TEST(emplace_map)
+  UNORDERED_AUTO_TEST(emplace_map)
-{
+  {
     test::check_instances check_;
 
     typedef boost::unordered_map<emplace_value, emplace_value,
@@ -398,10 +398,10 @@ UNORDERED_AUTO_TEST(emplace_map)
     BOOST_TEST(x.find(k2)->second == m2);
     BOOST_TEST_EQ(check_.instances(), 8);
     BOOST_TEST_EQ(check_.constructions(), 16);
-}
+  }
 
-UNORDERED_AUTO_TEST(emplace_multimap)
+  UNORDERED_AUTO_TEST(emplace_multimap)
-{
+  {
     test::check_instances check_;
 
     typedef boost::unordered_multimap<emplace_value, emplace_value,
@@ -464,10 +464,10 @@ UNORDERED_AUTO_TEST(emplace_multimap)
     BOOST_TEST(x.find(k2)->second == m2);
     BOOST_TEST_EQ(check_.instances(), 20);
     BOOST_TEST_EQ(check_.constructions(), 20);
-}
+  }
 
-UNORDERED_AUTO_TEST(try_emplace)
+  UNORDERED_AUTO_TEST(try_emplace)
-{
+  {
     test::check_instances check_;
 
     typedef boost::unordered_map<int, emplace_value> container;
@@ -513,7 +513,7 @@ UNORDERED_AUTO_TEST(try_emplace)
       x.try_emplace(r2.first, k2, 10, "xxx", 'a', 4, 5, 6, 7, 8, 9, 10));
     BOOST_TEST(r2.first->second == m2);
     BOOST_TEST_EQ(x.size(), 2u);
-}
+  }
 }
 
 RUN_TESTS()

test/unordered/equality_tests.cpp

@@ -15,8 +15,8 @@
 #include "../helpers/test.hpp"
 
 namespace equality_tests {
-struct mod_compare
+  struct mod_compare
-{
+  {
     bool alt_hash_;
 
     explicit mod_compare(bool alt_hash = false) : alt_hash_(alt_hash) {}
@@ -28,7 +28,7 @@ struct mod_compare
       return alt_hash_ ? static_cast<std::size_t>(x % 250)
                        : static_cast<std::size_t>((x + 5) % 250);
     }
-};
+  };
 
 #define UNORDERED_EQUALITY_SET_TEST(seq1, op, seq2)                            \
   {                                                                            \
@@ -56,8 +56,7 @@ struct mod_compare
 
 #define UNORDERED_EQUALITY_MULTIMAP_TEST(seq1, op, seq2)                       \
   {                                                                            \
-        boost::unordered_multimap<int, int, mod_compare, mod_compare> map1,    \
+    boost::unordered_multimap<int, int, mod_compare, mod_compare> map1, map2;  \
-            map2;                                                              \
     BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1)                    \
     BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2)                    \
     BOOST_TEST(map1 op map2);                                                  \
@@ -67,8 +66,8 @@ struct mod_compare
 #define UNORDERED_MAP_INSERT(r, map, item)                                     \
   map.insert(std::pair<int const, int> BOOST_PP_SEQ_TO_TUPLE(item));
 
-UNORDERED_AUTO_TEST(equality_size_tests)
+  UNORDERED_AUTO_TEST(equality_size_tests)
-{
+  {
     boost::unordered_set<int> x1, x2;
     BOOST_TEST(x1 == x2);
     BOOST_TEST(!(x1 != x2));
@@ -88,61 +87,61 @@ UNORDERED_AUTO_TEST(equality_size_tests)
     BOOST_TEST(!(x1 == x2));
     BOOST_TEST(x2 != x1);
     BOOST_TEST(!(x2 == x1));
-}
+  }
 
-UNORDERED_AUTO_TEST(equality_key_value_tests)
+  UNORDERED_AUTO_TEST(equality_key_value_tests)
-{
+  {
     UNORDERED_EQUALITY_MULTISET_TEST((1), !=, (2))
     UNORDERED_EQUALITY_SET_TEST((2), ==, (2))
     UNORDERED_EQUALITY_MAP_TEST(((1)(1))((2)(1)), !=, ((1)(1))((3)(1)))
-}
+  }
 
-UNORDERED_AUTO_TEST(equality_collision_test)
+  UNORDERED_AUTO_TEST(equality_collision_test)
-{
+  {
     UNORDERED_EQUALITY_MULTISET_TEST((1), !=, (501))
     UNORDERED_EQUALITY_MULTISET_TEST((1)(251), !=, (1)(501))
     UNORDERED_EQUALITY_MULTIMAP_TEST(((251)(1))((1)(1)), !=, ((501)(1))((1)(1)))
     UNORDERED_EQUALITY_MULTISET_TEST((1)(501), ==, (1)(501))
     UNORDERED_EQUALITY_SET_TEST((1)(501), ==, (501)(1))
-}
+  }
 
-UNORDERED_AUTO_TEST(equality_group_size_test)
+  UNORDERED_AUTO_TEST(equality_group_size_test)
-{
+  {
     UNORDERED_EQUALITY_MULTISET_TEST((10)(20)(20), !=, (10)(10)(20))
     UNORDERED_EQUALITY_MULTIMAP_TEST(
       ((10)(1))((20)(1))((20)(1)), !=, ((10)(1))((20)(1))((10)(1)))
     UNORDERED_EQUALITY_MULTIMAP_TEST(
       ((20)(1))((10)(1))((10)(1)), ==, ((10)(1))((20)(1))((10)(1)))
-}
+  }
 
-UNORDERED_AUTO_TEST(equality_map_value_test)
+  UNORDERED_AUTO_TEST(equality_map_value_test)
-{
+  {
     UNORDERED_EQUALITY_MAP_TEST(((1)(1)), !=, ((1)(2)))
     UNORDERED_EQUALITY_MAP_TEST(((1)(1)), ==, ((1)(1)))
     UNORDERED_EQUALITY_MULTIMAP_TEST(((1)(1)), !=, ((1)(2)))
     UNORDERED_EQUALITY_MULTIMAP_TEST(((1)(1))((1)(1)), !=, ((1)(1))((1)(2)))
     UNORDERED_EQUALITY_MULTIMAP_TEST(((1)(2))((1)(1)), ==, ((1)(1))((1)(2)))
     UNORDERED_EQUALITY_MULTIMAP_TEST(((1)(2))((1)(1)), !=, ((1)(1))((1)(3)))
-}
+  }
 
-UNORDERED_AUTO_TEST(equality_predicate_test)
+  UNORDERED_AUTO_TEST(equality_predicate_test)
-{
+  {
     UNORDERED_EQUALITY_SET_TEST((1), !=, (1001))
     UNORDERED_EQUALITY_MAP_TEST(((1)(2))((1001)(1)), !=, ((1001)(2))((1)(1)))
-}
+  }
 
-UNORDERED_AUTO_TEST(equality_multiple_group_test)
+  UNORDERED_AUTO_TEST(equality_multiple_group_test)
-{
+  {
     UNORDERED_EQUALITY_MULTISET_TEST(
       (1)(1)(1)(1001)(2001)(2001)(2)(1002)(3)(1003)(2003), ==,
       (3)(1003)(2003)(1002)(2)(2001)(2001)(1)(1001)(1)(1));
-}
+  }
 
-// Test that equality still works when the two containers have
+  // Test that equality still works when the two containers have
-// different hash functions but the same equality predicate.
+  // different hash functions but the same equality predicate.
 
-UNORDERED_AUTO_TEST(equality_different_hash_test)
+  UNORDERED_AUTO_TEST(equality_different_hash_test)
-{
+  {
     typedef boost::unordered_set<int, mod_compare, mod_compare> set;
     set set1(0, mod_compare(false), mod_compare(false));
     set set2(0, mod_compare(true), mod_compare(true));
@@ -159,7 +158,7 @@ UNORDERED_AUTO_TEST(equality_different_hash_test)
     set1.insert(20);
     set2.insert(10);
     BOOST_TEST(set1 == set2);
-}
+  }
 }
 
 RUN_TESTS()

test/unordered/erase_equiv_tests.cpp

@@ -30,8 +30,7 @@ struct write_pair_type
   template <class X1, class X2>
   void operator()(std::pair<X1, X2> const& x) const
   {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM << "(" << x.first << "," << x.second
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "(" << x.first << "," << x.second << ")";
-                                       << ")";
   }
 } write_pair;
 
@@ -159,8 +158,7 @@ bool general_erase_range_test(Container& x, std::size_t start, std::size_t end)
 template <class Container> void erase_subrange_tests(Container const& x)
 {
   for (std::size_t length = 0; length < x.size(); ++length) {
-        for (std::size_t position = 0; position < x.size() - length;
+    for (std::size_t position = 0; position < x.size() - length; ++position) {
-             ++position) {
       Container y(x);
       collide_list init(y.begin(), y.end());
       if (!general_erase_range_test(y, position, position + length)) {

test/unordered/erase_tests.cpp

@@ -22,11 +22,11 @@
 
 namespace erase_tests {
 
-test::seed_t initialize_seed(85638);
+  test::seed_t initialize_seed(85638);
 
-template <class Container>
+  template <class Container>
-void erase_tests1(Container*, test::random_generator generator)
+  void erase_tests1(Container*, test::random_generator generator)
-{
+  {
     typedef BOOST_DEDUCED_TYPENAME Container::iterator iterator;
     typedef BOOST_DEDUCED_TYPENAME Container::const_iterator c_iterator;
 
@@ -37,8 +37,8 @@ void erase_tests1(Container*, test::random_generator generator)
       test::random_values<Container> v(1000, generator);
       Container x(v.begin(), v.end());
       int iterations = 0;
-        for (BOOST_DEDUCED_TYPENAME test::random_values<Container>::iterator
+      for (BOOST_DEDUCED_TYPENAME test::random_values<Container>::iterator it =
-                 it = v.begin();
+             v.begin();
            it != v.end(); ++it) {
         std::size_t count = x.count(test::get_key<Container>(*it));
         std::size_t old_size = x.size();
@@ -99,12 +99,11 @@ void erase_tests1(Container*, test::random_generator generator)
         BOOST_TEST(next == x.erase(pos));
         --size;
         if (size > 0)
-                BOOST_TEST(
+          BOOST_TEST(index == 0 ? next == x.begin() : next == test::next(prev));
-                    index == 0 ? next == x.begin() : next == test::next(prev));
         BOOST_TEST(x.count(key) == count - 1);
         if (x.count(key) != count - 1) {
-                BOOST_LIGHTWEIGHT_TEST_OSTREAM << count << " => "
+          BOOST_LIGHTWEIGHT_TEST_OSTREAM << count << " => " << x.count(key)
-                                               << x.count(key) << std::endl;
+                                         << std::endl;
         }
         BOOST_TEST(x.size() == size);
         if (++iterations % 20 == 0)
@@ -158,15 +157,14 @@ void erase_tests1(Container*, test::random_generator generator)
 
         while (iterators.size() > 1) {
           std::size_t start = test::random_value(iterators.size());
-                std::size_t length =
+          std::size_t length = test::random_value(iterators.size() - start);
-                    test::random_value(iterators.size() - start);
           x.erase(iterators[start], iterators[start + length]);
           iterators.erase(test::next(iterators.begin(), start),
             test::next(iterators.begin(), start + length));
 
           BOOST_TEST(x.size() == iterators.size() - 1);
-                BOOST_DEDUCED_TYPENAME std::vector<c_iterator>::const_iterator
+          BOOST_DEDUCED_TYPENAME std::vector<c_iterator>::const_iterator i2 =
-                    i2 = iterators.begin();
+            iterators.begin();
           for (c_iterator i1 = x.cbegin(); i1 != x.cend(); ++i1) {
             BOOST_TEST(i1 == *i2);
             ++i2;
@@ -226,12 +224,11 @@ void erase_tests1(Container*, test::random_generator generator)
         x.quick_erase(pos);
         --size;
         if (size > 0)
-                BOOST_TEST(
+          BOOST_TEST(index == 0 ? next == x.begin() : next == test::next(prev));
-                    index == 0 ? next == x.begin() : next == test::next(prev));
         BOOST_TEST(x.count(key) == count - 1);
         if (x.count(key) != count - 1) {
-                BOOST_LIGHTWEIGHT_TEST_OSTREAM << count << " => "
+          BOOST_LIGHTWEIGHT_TEST_OSTREAM << count << " => " << x.count(key)
-                                               << x.count(key) << std::endl;
+                                         << std::endl;
         }
         BOOST_TEST(x.size() == size);
         if (++iterations % 20 == 0)
@@ -252,22 +249,22 @@ void erase_tests1(Container*, test::random_generator generator)
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
-}
+  }
 
-boost::unordered_set<test::object, test::hash, test::equal_to,
+  boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
-boost::unordered_multiset<test::object, test::hash, test::equal_to,
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, test::allocator2<test::object> >* test_multimap;
 
-using test::default_generator;
+  using test::default_generator;
-using test::generate_collisions;
+  using test::generate_collisions;
-using test::limited_range;
+  using test::limited_range;
 
-UNORDERED_TEST(
+  UNORDERED_TEST(
     erase_tests1, ((test_set)(test_multiset)(test_map)(test_multimap))(
                     (default_generator)(generate_collisions)(limited_range)))
 }

test/unordered/extract_tests.cpp

@@ -21,11 +21,11 @@
 
 namespace extract_tests {
 
-test::seed_t initialize_seed(85638);
+  test::seed_t initialize_seed(85638);
 
-template <class Container>
+  template <class Container>
-void extract_tests1(Container*, test::random_generator generator)
+  void extract_tests1(Container*, test::random_generator generator)
-{
+  {
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Extract by key.\n";
     {
       test::check_instances check_;
@@ -33,8 +33,8 @@ void extract_tests1(Container*, test::random_generator generator)
       test::random_values<Container> v(1000, generator);
       Container x(v.begin(), v.end());
       int iterations = 0;
-        for (BOOST_DEDUCED_TYPENAME test::random_values<Container>::iterator
+      for (BOOST_DEDUCED_TYPENAME test::random_values<Container>::iterator it =
-                 it = v.begin();
+             v.begin();
            it != v.end(); ++it) {
         std::size_t count = x.count(test::get_key<Container>(*it));
         std::size_t old_size = x.size();
@@ -116,21 +116,21 @@ void extract_tests1(Container*, test::random_generator generator)
     }
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
-}
+  }
 
-boost::unordered_set<test::object, test::hash, test::equal_to,
+  boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
-boost::unordered_multiset<test::object, test::hash, test::equal_to,
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, test::allocator2<test::object> >* test_multimap;
 
-using test::default_generator;
+  using test::default_generator;
-using test::generate_collisions;
+  using test::generate_collisions;
 
-UNORDERED_TEST(
+  UNORDERED_TEST(
     extract_tests1, ((test_set)(test_multiset)(test_map)(test_multimap))(
                       (default_generator)(generate_collisions)))
 }

test/unordered/find_tests.cpp

@@ -18,10 +18,10 @@
 
 namespace find_tests {
 
-test::seed_t initialize_seed(78937);
+  test::seed_t initialize_seed(78937);
 
-template <class X> void find_tests1(X*, test::random_generator generator)
+  template <class X> void find_tests1(X*, test::random_generator generator)
-{
+  {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
     {
@@ -37,22 +37,19 @@ template <class X> void find_tests1(X*, test::random_generator generator)
              tracker.begin();
            it1 != tracker.end(); ++it1) {
         BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it1);
-            BOOST_DEDUCED_TYPENAME X::const_iterator const_pos =
+        BOOST_DEDUCED_TYPENAME X::const_iterator const_pos = x_const.find(key);
-                x_const.find(key);
         iterator pos = x.find(key);
         BOOST_TEST(const_pos != x_const.end());
         BOOST_TEST(const_pos != x_const.end() &&
                    x_const.key_eq()(key, test::get_key<X>(*const_pos)));
         BOOST_TEST(pos != x.end());
-            BOOST_TEST(
+        BOOST_TEST(pos != x.end() && x.key_eq()(key, test::get_key<X>(*pos)));
-                pos != x.end() && x.key_eq()(key, test::get_key<X>(*pos)));
 
         BOOST_TEST(x.count(key) == tracker.count(key));
 
         test::compare_pairs(x.equal_range(key), tracker.equal_range(key),
           (BOOST_DEDUCED_TYPENAME X::value_type*)0);
-            test::compare_pairs(x_const.equal_range(key),
+        test::compare_pairs(x_const.equal_range(key), tracker.equal_range(key),
-                tracker.equal_range(key),
           (BOOST_DEDUCED_TYPENAME X::value_type*)0);
       }
 
@@ -87,38 +84,38 @@ template <class X> void find_tests1(X*, test::random_generator generator)
         BOOST_TEST(range.first == range.second);
       }
     }
-}
+  }
 
-struct compatible_key
+  struct compatible_key
-{
+  {
     test::object o_;
 
     compatible_key(test::object const& o) : o_(o) {}
-};
+  };
 
-struct compatible_hash
+  struct compatible_hash
-{
+  {
     test::hash hash_;
 
     std::size_t operator()(compatible_key const& k) const
     {
       return hash_(k.o_);
     }
-};
+  };
 
-struct compatible_predicate
+  struct compatible_predicate
-{
+  {
     test::equal_to equal_;
 
     bool operator()(compatible_key const& k1, compatible_key const& k2) const
     {
       return equal_(k1.o_, k2.o_);
     }
-};
+  };
 
-template <class X>
+  template <class X>
-void find_compatible_keys_test(X*, test::random_generator generator)
+  void find_compatible_keys_test(X*, test::random_generator generator)
-{
+  {
     typedef BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator
       value_iterator;
     test::random_values<X> v(500, generator);
@@ -138,25 +135,25 @@ void find_compatible_keys_test(X*, test::random_generator generator)
       BOOST_DEDUCED_TYPENAME X::key_type key = test::get_key<X>(*it);
       BOOST_TEST(x.find(key) == x.find(compatible_key(key), h, eq));
     }
-}
+  }
 
-boost::unordered_set<test::object, test::hash, test::equal_to,
+  boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_set;
-boost::unordered_multiset<test::object, test::hash, test::equal_to,
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, test::allocator1<test::object> >* test_multimap;
 
-using test::default_generator;
+  using test::default_generator;
-using test::generate_collisions;
+  using test::generate_collisions;
-using test::limited_range;
+  using test::limited_range;
 
-UNORDERED_TEST(
+  UNORDERED_TEST(
     find_tests1, ((test_set)(test_multiset)(test_map)(test_multimap))(
                    (default_generator)(generate_collisions)(limited_range)))
-UNORDERED_TEST(find_compatible_keys_test,
+  UNORDERED_TEST(find_compatible_keys_test,
     ((test_set)(test_multiset)(test_map)(test_multimap))(
                    (default_generator)(generate_collisions)(limited_range)))
 }

test/unordered/incomplete_test.cpp

@@ -13,52 +13,52 @@
 #include <utility>
 
 namespace x {
-struct D
+  struct D
-{
+  {
     boost::unordered_map<D, D> x;
-};
+  };
 }
 
 namespace incomplete_test {
-// Declare, but don't define some types.
+  // Declare, but don't define some types.
 
-struct value;
+  struct value;
-struct hash;
+  struct hash;
-struct equals;
+  struct equals;
-template <class T> struct allocator;
+  template <class T> struct allocator;
 
-// Declare some instances
+  // Declare some instances
 
-typedef boost::unordered_map<value, value, hash, equals,
+  typedef boost::unordered_map<value, value, hash, equals,
     allocator<std::pair<value const, value> > >
     map;
-typedef boost::unordered_multimap<value, value, hash, equals,
+  typedef boost::unordered_multimap<value, value, hash, equals,
     allocator<std::pair<value const, value> > >
     multimap;
-typedef boost::unordered_set<value, hash, equals, allocator<value> > set;
+  typedef boost::unordered_set<value, hash, equals, allocator<value> > set;
-typedef boost::unordered_multiset<value, hash, equals, allocator<value> >
+  typedef boost::unordered_multiset<value, hash, equals, allocator<value> >
     multiset;
 
-// Now define the types which are stored as members, as they are needed for
+  // Now define the types which are stored as members, as they are needed for
-// declaring struct members.
+  // declaring struct members.
 
-struct hash
+  struct hash
-{
+  {
     template <typename T> std::size_t operator()(T const&) const { return 0; }
-};
+  };
 
-struct equals
+  struct equals
-{
+  {
     template <typename T> bool operator()(T const&, T const&) const
     {
       return true;
     }
-};
+  };
 
-// This is a dubious way to implement an allocator, but good enough
+  // This is a dubious way to implement an allocator, but good enough
-// for this test.
+  // for this test.
-template <typename T> struct allocator : std::allocator<T>
+  template <typename T> struct allocator : std::allocator<T>
-{
+  {
     allocator() {}
 
     template <typename T2>
@@ -70,72 +70,72 @@ template <typename T> struct allocator : std::allocator<T>
     allocator(const std::allocator<T2>& other) : std::allocator<T>(other)
     {
     }
-};
+  };
 
-// Declare some members of a structs.
+  // Declare some members of a structs.
-//
+  //
-// Incomplete hash, equals and allocator aren't here supported at the
+  // Incomplete hash, equals and allocator aren't here supported at the
-// moment.
+  // moment.
 
-struct struct1
+  struct struct1
-{
+  {
     boost::unordered_map<struct1, struct1, hash, equals,
       allocator<std::pair<struct1 const, struct1> > >
       x;
-};
+  };
-struct struct2
+  struct struct2
-{
+  {
     boost::unordered_multimap<struct2, struct2, hash, equals,
       allocator<std::pair<struct2 const, struct2> > >
       x;
-};
+  };
-struct struct3
+  struct struct3
-{
+  {
     boost::unordered_set<struct3, hash, equals, allocator<struct3> > x;
-};
+  };
-struct struct4
+  struct struct4
-{
+  {
     boost::unordered_multiset<struct4, hash, equals, allocator<struct4> > x;
-};
+  };
 
-// Now define the value type.
+  // Now define the value type.
 
-struct value
+  struct value
-{
+  {
-};
+  };
 
-// Create some instances.
+  // Create some instances.
 
-incomplete_test::map m1;
+  incomplete_test::map m1;
-incomplete_test::multimap m2;
+  incomplete_test::multimap m2;
-incomplete_test::set s1;
+  incomplete_test::set s1;
-incomplete_test::multiset s2;
+  incomplete_test::multiset s2;
 
-incomplete_test::struct1 c1;
+  incomplete_test::struct1 c1;
-incomplete_test::struct2 c2;
+  incomplete_test::struct2 c2;
-incomplete_test::struct3 c3;
+  incomplete_test::struct3 c3;
-incomplete_test::struct4 c4;
+  incomplete_test::struct4 c4;
 
-// Now declare, but don't define, the operators required for comparing
+  // Now declare, but don't define, the operators required for comparing
-// elements.
+  // elements.
 
-std::size_t hash_value(value const&);
+  std::size_t hash_value(value const&);
-bool operator==(value const&, value const&);
+  bool operator==(value const&, value const&);
 
-std::size_t hash_value(struct1 const&);
+  std::size_t hash_value(struct1 const&);
-std::size_t hash_value(struct2 const&);
+  std::size_t hash_value(struct2 const&);
-std::size_t hash_value(struct3 const&);
+  std::size_t hash_value(struct3 const&);
-std::size_t hash_value(struct4 const&);
+  std::size_t hash_value(struct4 const&);
 
-bool operator==(struct1 const&, struct1 const&);
+  bool operator==(struct1 const&, struct1 const&);
-bool operator==(struct2 const&, struct2 const&);
+  bool operator==(struct2 const&, struct2 const&);
-bool operator==(struct3 const&, struct3 const&);
+  bool operator==(struct3 const&, struct3 const&);
-bool operator==(struct4 const&, struct4 const&);
+  bool operator==(struct4 const&, struct4 const&);
 
-// And finally use these
+  // And finally use these
 
-void use_types()
+  void use_types()
-{
+  {
     incomplete_test::value x;
     m1[x] = x;
     m2.insert(std::make_pair(x, x));
@@ -146,22 +146,22 @@ void use_types()
     c2.x.insert(std::make_pair(c2, c2));
     c3.x.insert(c3);
     c4.x.insert(c4);
-}
+  }
 
-// And finally define the operators required for comparing elements.
+  // And finally define the operators required for comparing elements.
 
-std::size_t hash_value(value const&) { return 0; }
+  std::size_t hash_value(value const&) { return 0; }
-bool operator==(value const&, value const&) { return true; }
+  bool operator==(value const&, value const&) { return true; }
 
-std::size_t hash_value(struct1 const&) { return 0; }
+  std::size_t hash_value(struct1 const&) { return 0; }
-std::size_t hash_value(struct2 const&) { return 0; }
+  std::size_t hash_value(struct2 const&) { return 0; }
-std::size_t hash_value(struct3 const&) { return 0; }
+  std::size_t hash_value(struct3 const&) { return 0; }
-std::size_t hash_value(struct4 const&) { return 0; }
+  std::size_t hash_value(struct4 const&) { return 0; }
 
-bool operator==(struct1 const&, struct1 const&) { return true; }
+  bool operator==(struct1 const&, struct1 const&) { return true; }
-bool operator==(struct2 const&, struct2 const&) { return true; }
+  bool operator==(struct2 const&, struct2 const&) { return true; }
-bool operator==(struct3 const&, struct3 const&) { return true; }
+  bool operator==(struct3 const&, struct3 const&) { return true; }
-bool operator==(struct4 const&, struct4 const&) { return true; }
+  bool operator==(struct4 const&, struct4 const&) { return true; }
 }
 
 int main()

test/unordered/insert_hint_tests.cpp

@@ -17,18 +17,18 @@
 #include <set>
 
 namespace insert_hint {
-UNORDERED_AUTO_TEST(insert_hint_empty)
+  UNORDERED_AUTO_TEST(insert_hint_empty)
-{
+  {
     typedef boost::unordered_multiset<int> container;
     container x;
     x.insert(x.cbegin(), 10);
     BOOST_TEST_EQ(x.size(), 1u);
     BOOST_TEST_EQ(x.count(10), 1u);
     test::check_equivalent_keys(x);
-}
+  }
 
-UNORDERED_AUTO_TEST(insert_hint_empty2)
+  UNORDERED_AUTO_TEST(insert_hint_empty2)
-{
+  {
     typedef boost::unordered_multimap<std::string, int> container;
     container x;
     x.emplace_hint(x.cbegin(), "hello", 50);
@@ -36,10 +36,10 @@ UNORDERED_AUTO_TEST(insert_hint_empty2)
     BOOST_TEST_EQ(x.count("hello"), 1u);
     BOOST_TEST_EQ(x.find("hello")->second, 50);
     test::check_equivalent_keys(x);
-}
+  }
 
-UNORDERED_AUTO_TEST(insert_hint_single)
+  UNORDERED_AUTO_TEST(insert_hint_single)
-{
+  {
     typedef boost::unordered_multiset<std::string> container;
     container x;
     x.insert("equal");
@@ -47,10 +47,10 @@ UNORDERED_AUTO_TEST(insert_hint_single)
     BOOST_TEST_EQ(x.size(), 2u);
     BOOST_TEST_EQ(x.count("equal"), 2u);
     test::check_equivalent_keys(x);
-}
+  }
 
-UNORDERED_AUTO_TEST(insert_hint_single2)
+  UNORDERED_AUTO_TEST(insert_hint_single2)
-{
+  {
     typedef boost::unordered_multimap<int, std::string> container;
     container x;
     x.emplace(10, "one");
@@ -67,10 +67,10 @@ UNORDERED_AUTO_TEST(insert_hint_single2)
     BOOST_TEST(v0 != v1);
 
     test::check_equivalent_keys(x);
-}
+  }
 
-UNORDERED_AUTO_TEST(insert_hint_multiple)
+  UNORDERED_AUTO_TEST(insert_hint_multiple)
-{
+  {
     for (unsigned int size = 0; size < 10; ++size) {
       for (unsigned int offset = 0; offset <= size; ++offset) {
         typedef boost::unordered_multiset<std::string> container;
@@ -94,20 +94,20 @@ UNORDERED_AUTO_TEST(insert_hint_multiple)
         test::check_equivalent_keys(x);
       }
     }
-}
+  }
 
-UNORDERED_AUTO_TEST(insert_hint_unique)
+  UNORDERED_AUTO_TEST(insert_hint_unique)
-{
+  {
     typedef boost::unordered_set<int> container;
     container x;
     x.insert(x.cbegin(), 10);
     BOOST_TEST_EQ(x.size(), 1u);
     BOOST_TEST_EQ(x.count(10), 1u);
     test::check_equivalent_keys(x);
-}
+  }
 
-UNORDERED_AUTO_TEST(insert_hint_unique_single)
+  UNORDERED_AUTO_TEST(insert_hint_unique_single)
-{
+  {
     typedef boost::unordered_set<int> container;
     container x;
     x.insert(10);
@@ -122,7 +122,7 @@ UNORDERED_AUTO_TEST(insert_hint_unique_single)
     BOOST_TEST_EQ(x.count(10), 1u);
     BOOST_TEST_EQ(x.count(20), 1u);
     test::check_equivalent_keys(x);
-}
+  }
 }
 
 RUN_TESTS()

test/unordered/insert_stable_tests.cpp

@@ -13,8 +13,8 @@
 #include "../helpers/test.hpp"
 
 namespace insert_stable {
-struct member
+  struct member
-{
+  {
     int tag1_;
     int tag2_;
 
@@ -30,7 +30,7 @@ struct member
     {
       return x.tag1_ != y.tag1_;
     }
-};
+  };
 }
 
 #ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
@@ -39,10 +39,10 @@ namespace boost
 namespace insert_stable
 #endif
 {
-std::size_t hash_value(insert_stable::member const& x)
+  std::size_t hash_value(insert_stable::member const& x)
-{
+  {
     return static_cast<std::size_t>(x.tag1_);
-}
+  }
 }
 
 // This is no longer supported, as there's no longer an efficient way to get to

test/unordered/insert_tests.cpp

@@ -23,11 +23,11 @@
 
 namespace insert_tests {
 
-test::seed_t initialize_seed(243432);
+  test::seed_t initialize_seed(243432);
 
-template <class X>
+  template <class X>
-void unique_insert_tests1(X*, test::random_generator generator)
+  void unique_insert_tests1(X*, test::random_generator generator)
-{
+  {
     test::check_instances check_;
 
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
@@ -44,8 +44,7 @@ void unique_insert_tests1(X*, test::random_generator generator)
              v.begin();
            it != v.end(); ++it) {
 
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+        BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
-                x.bucket_count();
         float b = x.max_load_factor();
 
         std::pair<iterator, bool> r1 = x.insert(*it);
@@ -76,8 +75,7 @@ void unique_insert_tests1(X*, test::random_generator generator)
              v.begin();
            it != v.end(); ++it) {
 
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+        BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
-                x.bucket_count();
         float b = x.max_load_factor();
 
         typename X::value_type value = *it;
@@ -97,11 +95,11 @@ void unique_insert_tests1(X*, test::random_generator generator)
 
       test::check_equivalent_keys(x);
     }
-}
+  }
 
-template <class X>
+  template <class X>
-void equivalent_insert_tests1(X*, test::random_generator generator)
+  void equivalent_insert_tests1(X*, test::random_generator generator)
-{
+  {
     test::check_instances check_;
 
     UNORDERED_SUB_TEST(
@@ -114,8 +112,7 @@ void equivalent_insert_tests1(X*, test::random_generator generator)
       for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it =
              v.begin();
            it != v.end(); ++it) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+        BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
-                x.bucket_count();
         float b = x.max_load_factor();
 
         BOOST_DEDUCED_TYPENAME X::iterator r1 = x.insert(*it);
@@ -144,13 +141,11 @@ void equivalent_insert_tests1(X*, test::random_generator generator)
       for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it =
              v.begin();
            it != v.end(); ++it) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+        BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
-                x.bucket_count();
         float b = x.max_load_factor();
 
         typename X::value_type value = *it;
-            BOOST_DEDUCED_TYPENAME X::iterator r1 =
+        BOOST_DEDUCED_TYPENAME X::iterator r1 = x.insert(boost::move(value));
-                x.insert(boost::move(value));
         BOOST_DEDUCED_TYPENAME test::ordered<X>::iterator r2 =
           tracker.insert(*it);
 
@@ -165,10 +160,10 @@ void equivalent_insert_tests1(X*, test::random_generator generator)
 
       test::check_equivalent_keys(x);
     }
-}
+  }
 
-template <class X> void insert_tests2(X*, test::random_generator generator)
+  template <class X> void insert_tests2(X*, test::random_generator generator)
-{
+  {
     typedef BOOST_DEDUCED_TYPENAME test::ordered<X> tracker_type;
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
@@ -185,8 +180,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
       for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it =
              v.begin();
            it != v.end(); ++it) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+        BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
-                x.bucket_count();
         float b = x.max_load_factor();
 
         iterator r1 = x.insert(x.begin(), *it);
@@ -215,8 +209,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
       for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it =
              v.begin();
            it != v.end(); ++it) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+        BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
-                x.bucket_count();
         float b = x.max_load_factor();
 
         const_iterator r1 = x.insert(x_const.end(), *it);
@@ -245,8 +238,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
       for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it =
              v.begin();
            it != v.end(); ++it) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+        BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
-                x.bucket_count();
         float b = x.max_load_factor();
 
         pos = x.insert(pos, *it);
@@ -275,8 +267,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
       for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it =
              v.begin();
            it != v.end(); ++it) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+        BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
-                x.bucket_count();
         float b = x.max_load_factor();
 
         typename X::value_type value = *it;
@@ -305,8 +296,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
       for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it =
              v.begin();
            it != v.end(); ++it) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+        BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
-                x.bucket_count();
         float b = x.max_load_factor();
 
         x.insert(it, test::next(it));
@@ -359,9 +349,10 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
       X x;
 
       test::random_values<X> v(1000, generator);
-        BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator
+      BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator begin =
-            begin = v.begin(),
+                                                                      v.begin(),
-            end = v.end();
+                                                                    end =
+                                                                      v.end();
       x.insert(test::input_iterator(begin), test::input_iterator(end));
       test::check_container(x, v);
 
@@ -389,10 +380,8 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
 
       test::random_values<X> v1(500, generator);
       test::random_values<X> v2(500, generator);
-        x.insert(
+      x.insert(test::copy_iterator(v1.begin()), test::copy_iterator(v1.end()));
-            test::copy_iterator(v1.begin()), test::copy_iterator(v1.end()));
+      x.insert(test::copy_iterator(v2.begin()), test::copy_iterator(v2.end()));
-        x.insert(
-            test::copy_iterator(v2.begin()), test::copy_iterator(v2.end()));
 
       test::check_equivalent_keys(x);
     }
@@ -412,8 +401,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
             x.bucket_count();
           float b = x.max_load_factor();
 
-                BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator next =
+          BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator next = it;
-                    it;
           for (std::size_t j = test::random_value(20); j > 0; ++j) {
             ++next;
             if (next == v.end()) {
@@ -435,11 +423,11 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
       }
     }
-}
+  }
 
-template <class X>
+  template <class X>
-void unique_emplace_tests1(X*, test::random_generator generator)
+  void unique_emplace_tests1(X*, test::random_generator generator)
-{
+  {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     typedef test::ordered<X> ordered;
 
@@ -470,11 +458,11 @@ void unique_emplace_tests1(X*, test::random_generator generator)
 
     tracker.compare(x);
     test::check_equivalent_keys(x);
-}
+  }
 
-template <class X>
+  template <class X>
-void equivalent_emplace_tests1(X*, test::random_generator generator)
+  void equivalent_emplace_tests1(X*, test::random_generator generator)
-{
+  {
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
 
@@ -499,10 +487,11 @@ void equivalent_emplace_tests1(X*, test::random_generator generator)
 
     tracker.compare(x);
     test::check_equivalent_keys(x);
-}
+  }
 
-template <class X> void move_emplace_tests(X*, test::random_generator generator)
+  template <class X>
-{
+  void move_emplace_tests(X*, test::random_generator generator)
+  {
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
 
@@ -526,10 +515,10 @@ template <class X> void move_emplace_tests(X*, test::random_generator generator)
 
     tracker.compare(x);
     test::check_equivalent_keys(x);
-}
+  }
 
-template <class X> void default_emplace_tests(X*, test::random_generator)
+  template <class X> void default_emplace_tests(X*, test::random_generator)
-{
+  {
 #if !BOOST_UNORDERED_SUN_WORKAROUNDS1
     bool is_unique = test::has_unique_keys<X>::value;
 
@@ -561,10 +550,10 @@ template <class X> void default_emplace_tests(X*, test::random_generator)
     BOOST_TEST(x.count(test::get_key<X>(y)) == (is_unique ? 1u : 2u));
     BOOST_TEST(*x.equal_range(test::get_key<X>(y)).first == y);
 #endif
-}
+  }
 
-template <class X> void map_tests(X*, test::random_generator generator)
+  template <class X> void map_tests(X*, test::random_generator generator)
-{
+  {
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
 
@@ -586,10 +575,10 @@ template <class X> void map_tests(X*, test::random_generator generator)
 
     tracker.compare(x);
     test::check_equivalent_keys(x);
-}
+  }
 
-template <class X> void map_tests2(X*, test::random_generator generator)
+  template <class X> void map_tests2(X*, test::random_generator generator)
-{
+  {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
     UNORDERED_SUB_TEST("insert_or_assign")
@@ -603,12 +592,10 @@ template <class X> void map_tests2(X*, test::random_generator generator)
       for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it =
              v.begin();
            it != v.end(); ++it) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+        BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
-                x.bucket_count();
         float b = x.max_load_factor();
 
-            std::pair<iterator, bool> r =
+        std::pair<iterator, bool> r = x.insert_or_assign(it->first, it->second);
-                x.insert_or_assign(it->first, it->second);
         BOOST_TEST(*r.first == *it);
 
         tracker[it->first] = it->second;
@@ -634,8 +621,7 @@ template <class X> void map_tests2(X*, test::random_generator generator)
       for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it =
              v.begin();
            it != v.end(); ++it) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+        BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
-                x.bucket_count();
         float b = x.max_load_factor();
 
         iterator r = x.insert_or_assign(x.begin(), it->first, it->second);
@@ -664,8 +650,7 @@ template <class X> void map_tests2(X*, test::random_generator generator)
       for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it =
              v.begin();
            it != v.end(); ++it) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+        BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
-                x.bucket_count();
         float b = x.max_load_factor();
 
         iterator r = x.insert_or_assign(x.end(), it->first, it->second);
@@ -695,8 +680,7 @@ template <class X> void map_tests2(X*, test::random_generator generator)
       for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it =
              v.begin();
            it != v.end(); ++it) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+        BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
-                x.bucket_count();
         float b = x.max_load_factor();
 
         iterator r = x.insert_or_assign(last, it->first, it->second);
@@ -715,10 +699,11 @@ template <class X> void map_tests2(X*, test::random_generator generator)
       tracker.compare(x);
       test::check_equivalent_keys(x);
     }
-}
+  }
 
-template <class X> void try_emplace_tests(X*, test::random_generator generator)
+  template <class X>
-{
+  void try_emplace_tests(X*, test::random_generator generator)
+  {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
     UNORDERED_SUB_TEST("try_emplace(key, value)")
@@ -732,8 +717,7 @@ template <class X> void try_emplace_tests(X*, test::random_generator generator)
       for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it =
              v.begin();
            it != v.end(); ++it) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+        BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
-                x.bucket_count();
         float b = x.max_load_factor();
 
         iterator pos = x.find(it->first);
@@ -774,8 +758,7 @@ template <class X> void try_emplace_tests(X*, test::random_generator generator)
       for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it =
              v.begin();
            it != v.end(); ++it) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+        BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
-                x.bucket_count();
         float b = x.max_load_factor();
 
         iterator pos = x.find(it->first);
@@ -813,15 +796,13 @@ template <class X> void try_emplace_tests(X*, test::random_generator generator)
       for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it =
              v.begin();
            it != v.end(); ++it) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+        BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
-                x.bucket_count();
         float b = x.max_load_factor();
 
         iterator pos = x.find(it->first);
         bool found = pos != x.end();
 
-            typename X::iterator r =
+        typename X::iterator r = x.try_emplace(r.end(), it->first, it->second);
-                x.try_emplace(r.end(), it->first, it->second);
         if (found) {
           BOOST_TEST(pos == r);
         }
@@ -852,8 +833,7 @@ template <class X> void try_emplace_tests(X*, test::random_generator generator)
       for (BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it =
              v.begin();
            it != v.end(); ++it) {
-            BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count =
+        BOOST_DEDUCED_TYPENAME X::size_type old_bucket_count = x.bucket_count();
-                x.bucket_count();
         float b = x.max_load_factor();
 
         iterator pos = x.find(it->first);
@@ -876,14 +856,14 @@ template <class X> void try_emplace_tests(X*, test::random_generator generator)
 
       test::check_equivalent_keys(x);
     }
-}
+  }
 
-// Some tests for when the range's value type doesn't match the container's
+  // Some tests for when the range's value type doesn't match the container's
-// value type.
+  // value type.
 
-template <class X>
+  template <class X>
-void map_insert_range_test1(X*, test::random_generator generator)
+  void map_insert_range_test1(X*, test::random_generator generator)
-{
+  {
     test::check_instances check_;
 
     typedef test::list<std::pair<BOOST_DEDUCED_TYPENAME X::key_type,
@@ -896,11 +876,11 @@ void map_insert_range_test1(X*, test::random_generator generator)
     x.insert(l.begin(), l.end());
 
     test::check_equivalent_keys(x);
-}
+  }
 
-template <class X>
+  template <class X>
-void map_insert_range_test2(X*, test::random_generator generator)
+  void map_insert_range_test2(X*, test::random_generator generator)
-{
+  {
     test::check_instances check_;
 
     typedef test::list<std::pair<BOOST_DEDUCED_TYPENAME X::key_type const,
@@ -915,75 +895,74 @@ void map_insert_range_test2(X*, test::random_generator generator)
     x.insert(l.begin(), l.end());
 
     test::check_equivalent_keys(x);
-}
+  }
 
-boost::unordered_set<test::movable, test::hash, test::equal_to,
+  boost::unordered_set<test::movable, test::hash, test::equal_to,
     std::allocator<test::movable> >* test_set_std_alloc;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, std::allocator<test::object> >* test_multimap_std_alloc;
 
-boost::unordered_set<test::object, test::hash, test::equal_to,
+  boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
-boost::unordered_multiset<test::movable, test::hash, test::equal_to,
+  boost::unordered_multiset<test::movable, test::hash, test::equal_to,
     test::allocator2<test::movable> >* test_multiset;
-boost::unordered_map<test::movable, test::movable, test::hash, test::equal_to,
+  boost::unordered_map<test::movable, test::movable, test::hash, test::equal_to,
     test::allocator2<test::movable> >* test_map;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, test::allocator1<test::object> >* test_multimap;
 
-using test::default_generator;
+  using test::default_generator;
-using test::generate_collisions;
+  using test::generate_collisions;
-using test::limited_range;
+  using test::limited_range;
 
-UNORDERED_TEST(unique_insert_tests1,
+  UNORDERED_TEST(unique_insert_tests1,
     ((test_set_std_alloc)(test_set)(test_map))(
                    (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(equivalent_insert_tests1,
+  UNORDERED_TEST(equivalent_insert_tests1,
     ((test_multimap_std_alloc)(test_multiset)(test_multimap))(
                    (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(
+  UNORDERED_TEST(insert_tests2,
-    insert_tests2, ((test_multimap_std_alloc)(test_set)(test_multiset)(
+    ((test_multimap_std_alloc)(test_set)(test_multiset)(test_map)(
-                       test_map)(test_multimap))(
+      test_multimap))((default_generator)(generate_collisions)(limited_range)))
-                       (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(unique_emplace_tests1,
+  UNORDERED_TEST(unique_emplace_tests1,
     ((test_set_std_alloc)(test_set)(test_map))(
                    (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(equivalent_emplace_tests1,
+  UNORDERED_TEST(equivalent_emplace_tests1,
     ((test_multimap_std_alloc)(test_multiset)(test_multimap))(
                    (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(move_emplace_tests,
+  UNORDERED_TEST(move_emplace_tests,
     ((test_set_std_alloc)(test_multimap_std_alloc)(test_set)(test_map)(
       test_multiset)(test_multimap))(
                    (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(default_emplace_tests,
+  UNORDERED_TEST(default_emplace_tests,
     ((test_set_std_alloc)(test_multimap_std_alloc)(test_set)(test_map)(
       test_multiset)(test_multimap))(
                    (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(map_tests,
+  UNORDERED_TEST(map_tests,
     ((test_map))((default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(
+  UNORDERED_TEST(
     map_tests2, ((test_map))((default_generator)(generate_collisions)))
 
-UNORDERED_TEST(map_insert_range_test1,
+  UNORDERED_TEST(map_insert_range_test1,
     ((test_multimap_std_alloc)(test_map)(test_multimap))(
                    (default_generator)(generate_collisions)(limited_range)))
 
-UNORDERED_TEST(map_insert_range_test2,
+  UNORDERED_TEST(map_insert_range_test2,
     ((test_multimap_std_alloc)(test_map)(test_multimap))(
                    (default_generator)(generate_collisions)(limited_range)))
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 
-struct initialize_from_two_ints
+  struct initialize_from_two_ints
-{
+  {
     int a, b;
 
     friend std::size_t hash_value(initialize_from_two_ints const& x)
@@ -995,10 +974,10 @@ struct initialize_from_two_ints
     {
       return a == x.a && b == x.b;
     }
-};
+  };
 
-UNORDERED_AUTO_TEST(insert_initializer_list_set)
+  UNORDERED_AUTO_TEST(insert_initializer_list_set)
-{
+  {
     boost::unordered_set<int> set;
     set.insert({1, 2, 3, 1});
     BOOST_TEST_EQ(set.size(), 3u);
@@ -1032,12 +1011,12 @@ UNORDERED_AUTO_TEST(insert_initializer_list_set)
     BOOST_TEST(set2.find({5, 6}) != set2.end());
     BOOST_TEST(set2.find({7, 8}) != set2.end());
     BOOST_TEST(set2.find({8, 7}) == set2.end());
-}
+  }
 
 #if !BOOST_WORKAROUND(BOOST_MSVC, == 1800)
 
-UNORDERED_AUTO_TEST(insert_initializer_list_multiset)
+  UNORDERED_AUTO_TEST(insert_initializer_list_multiset)
-{
+  {
     boost::unordered_multiset<std::string> multiset;
     // multiset.insert({});
     BOOST_TEST(multiset.empty());
@@ -1050,33 +1029,33 @@ UNORDERED_AUTO_TEST(insert_initializer_list_multiset)
     BOOST_TEST_EQ(multiset.count("a"), 2u);
     BOOST_TEST_EQ(multiset.count("b"), 1u);
     BOOST_TEST_EQ(multiset.count("c"), 0u);
-}
+  }
 
 #endif
 
-UNORDERED_AUTO_TEST(insert_initializer_list_map)
+  UNORDERED_AUTO_TEST(insert_initializer_list_map)
-{
+  {
     boost::unordered_map<std::string, std::string> map;
     // map.insert({});
     BOOST_TEST(map.empty());
     map.insert({{"a", "b"}, {"a", "b"}, {"d", ""}});
     BOOST_TEST_EQ(map.size(), 2u);
-}
+  }
 
-UNORDERED_AUTO_TEST(insert_initializer_list_multimap)
+  UNORDERED_AUTO_TEST(insert_initializer_list_multimap)
-{
+  {
     boost::unordered_multimap<std::string, std::string> multimap;
     // multimap.insert({});
     BOOST_TEST(multimap.empty());
     multimap.insert({{"a", "b"}, {"a", "b"}, {"d", ""}});
     BOOST_TEST_EQ(multimap.size(), 3u);
     BOOST_TEST_EQ(multimap.count("a"), 2u);
-}
+  }
 
 #endif
 
-struct overloaded_constructor
+  struct overloaded_constructor
-{
+  {
     overloaded_constructor(int x1_ = 1, int x2_ = 2, int x3_ = 3, int x4_ = 4)
         : x1(x1_), x2(x2_), x3(x3_), x4(x4_)
     {
@@ -1098,10 +1077,10 @@ struct overloaded_constructor
       boost::hash_combine(hash, x.x4);
       return hash;
     }
-};
+  };
 
-UNORDERED_AUTO_TEST(map_emplace_test)
+  UNORDERED_AUTO_TEST(map_emplace_test)
-{
+  {
     {
       boost::unordered_map<int, overloaded_constructor, test::hash,
         test::equal_to,
@@ -1110,17 +1089,17 @@ UNORDERED_AUTO_TEST(map_emplace_test)
 
 #if !BOOST_UNORDERED_SUN_WORKAROUNDS1
       x.emplace();
-        BOOST_TEST(x.find(0) != x.end() &&
+      BOOST_TEST(
-                   x.find(0)->second == overloaded_constructor());
+        x.find(0) != x.end() && x.find(0)->second == overloaded_constructor());
 #endif
 
       x.emplace(2, 3);
-        BOOST_TEST(x.find(2) != x.end() &&
+      BOOST_TEST(
-                   x.find(2)->second == overloaded_constructor(3));
+        x.find(2) != x.end() && x.find(2)->second == overloaded_constructor(3));
 
       x.try_emplace(5);
-        BOOST_TEST(x.find(5) != x.end() &&
+      BOOST_TEST(
-                   x.find(5)->second == overloaded_constructor());
+        x.find(5) != x.end() && x.find(5)->second == overloaded_constructor());
     }
 
     {
@@ -1131,18 +1110,18 @@ UNORDERED_AUTO_TEST(map_emplace_test)
 
 #if !BOOST_UNORDERED_SUN_WORKAROUNDS1
       x.emplace();
-        BOOST_TEST(x.find(0) != x.end() &&
+      BOOST_TEST(
-                   x.find(0)->second == overloaded_constructor());
+        x.find(0) != x.end() && x.find(0)->second == overloaded_constructor());
 #endif
 
       x.emplace(2, 3);
-        BOOST_TEST(x.find(2) != x.end() &&
+      BOOST_TEST(
-                   x.find(2)->second == overloaded_constructor(3));
+        x.find(2) != x.end() && x.find(2)->second == overloaded_constructor(3));
+    }
   }
-}
 
-UNORDERED_AUTO_TEST(set_emplace_test)
+  UNORDERED_AUTO_TEST(set_emplace_test)
-{
+  {
     boost::unordered_set<overloaded_constructor> x;
     overloaded_constructor check;
 
@@ -1170,28 +1149,28 @@ UNORDERED_AUTO_TEST(set_emplace_test)
     x.emplace(7, 8, 9, 10);
     check = overloaded_constructor(7, 8, 9, 10);
     BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
-}
+  }
 
-struct derived_from_piecewise_construct_t
+  struct derived_from_piecewise_construct_t
     : boost::unordered::piecewise_construct_t
-{
+  {
-};
+  };
 
-derived_from_piecewise_construct_t piecewise_rvalue()
+  derived_from_piecewise_construct_t piecewise_rvalue()
-{
+  {
     return derived_from_piecewise_construct_t();
-}
+  }
 
-struct convertible_to_piecewise
+  struct convertible_to_piecewise
-{
+  {
     operator boost::unordered::piecewise_construct_t() const
     {
       return boost::unordered::piecewise_construct;
     }
-};
+  };
 
-UNORDERED_AUTO_TEST(map_emplace_test2)
+  UNORDERED_AUTO_TEST(map_emplace_test2)
-{
+  {
     // Emulating piecewise construction with boost::tuple bypasses the
     // allocator's construct method, but still uses test destroy method.
     test::detail::disable_construction_tracking _scoped;
@@ -1206,15 +1185,15 @@ UNORDERED_AUTO_TEST(map_emplace_test2)
 
       x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(),
         boost::make_tuple());
-        BOOST_TEST(x.find(overloaded_constructor()) != x.end() &&
+      BOOST_TEST(
-                   x.find(overloaded_constructor())->second ==
+        x.find(overloaded_constructor()) != x.end() &&
-                       overloaded_constructor());
+        x.find(overloaded_constructor())->second == overloaded_constructor());
 
-        x.emplace(convertible_to_piecewise(), boost::make_tuple(1),
+      x.emplace(
-            boost::make_tuple());
+        convertible_to_piecewise(), boost::make_tuple(1), boost::make_tuple());
-        BOOST_TEST(x.find(overloaded_constructor(1)) != x.end() &&
+      BOOST_TEST(
-                   x.find(overloaded_constructor(1))->second ==
+        x.find(overloaded_constructor(1)) != x.end() &&
-                       overloaded_constructor());
+        x.find(overloaded_constructor(1))->second == overloaded_constructor());
 
       x.emplace(piecewise_rvalue(), boost::make_tuple(2, 3),
         boost::make_tuple(4, 5, 6));
@@ -1231,14 +1210,14 @@ UNORDERED_AUTO_TEST(map_emplace_test2)
       x.clear();
 
       x.try_emplace(overloaded_constructor());
-        BOOST_TEST(x.find(overloaded_constructor()) != x.end() &&
+      BOOST_TEST(
-                   x.find(overloaded_constructor())->second ==
+        x.find(overloaded_constructor()) != x.end() &&
-                       overloaded_constructor());
+        x.find(overloaded_constructor())->second == overloaded_constructor());
 
       x.try_emplace(1);
-        BOOST_TEST(x.find(overloaded_constructor(1)) != x.end() &&
+      BOOST_TEST(
-                   x.find(overloaded_constructor(1))->second ==
+        x.find(overloaded_constructor(1)) != x.end() &&
-                       overloaded_constructor());
+        x.find(overloaded_constructor(1))->second == overloaded_constructor());
 
       x.try_emplace(overloaded_constructor(2, 3), 4, 5, 6);
       BOOST_TEST(x.find(overloaded_constructor(2, 3)) != x.end() &&
@@ -1248,14 +1227,14 @@ UNORDERED_AUTO_TEST(map_emplace_test2)
       x.clear();
 
       x.try_emplace(x.begin(), overloaded_constructor());
-        BOOST_TEST(x.find(overloaded_constructor()) != x.end() &&
+      BOOST_TEST(
-                   x.find(overloaded_constructor())->second ==
+        x.find(overloaded_constructor()) != x.end() &&
-                       overloaded_constructor());
+        x.find(overloaded_constructor())->second == overloaded_constructor());
 
       x.try_emplace(x.end(), 1);
-        BOOST_TEST(x.find(overloaded_constructor(1)) != x.end() &&
+      BOOST_TEST(
-                   x.find(overloaded_constructor(1))->second ==
+        x.find(overloaded_constructor(1)) != x.end() &&
-                       overloaded_constructor());
+        x.find(overloaded_constructor(1))->second == overloaded_constructor());
 
       x.try_emplace(x.begin(), overloaded_constructor(2, 3), 4, 5, 6);
       BOOST_TEST(x.find(overloaded_constructor(2, 3)) != x.end() &&
@@ -1264,8 +1243,8 @@ UNORDERED_AUTO_TEST(map_emplace_test2)
     }
 
     {
-        boost::unordered_multimap<overloaded_constructor,
+      boost::unordered_multimap<overloaded_constructor, overloaded_constructor,
-            overloaded_constructor, boost::hash<overloaded_constructor>,
+        boost::hash<overloaded_constructor>,
         std::equal_to<overloaded_constructor>,
         test::allocator1<std::pair<overloaded_constructor const,
           overloaded_constructor> > >
@@ -1273,15 +1252,15 @@ UNORDERED_AUTO_TEST(map_emplace_test2)
 
       x.emplace(boost::unordered::piecewise_construct, boost::make_tuple(),
         boost::make_tuple());
-        BOOST_TEST(x.find(overloaded_constructor()) != x.end() &&
+      BOOST_TEST(
-                   x.find(overloaded_constructor())->second ==
+        x.find(overloaded_constructor()) != x.end() &&
-                       overloaded_constructor());
+        x.find(overloaded_constructor())->second == overloaded_constructor());
 
-        x.emplace(convertible_to_piecewise(), boost::make_tuple(1),
+      x.emplace(
-            boost::make_tuple());
+        convertible_to_piecewise(), boost::make_tuple(1), boost::make_tuple());
-        BOOST_TEST(x.find(overloaded_constructor(1)) != x.end() &&
+      BOOST_TEST(
-                   x.find(overloaded_constructor(1))->second ==
+        x.find(overloaded_constructor(1)) != x.end() &&
-                       overloaded_constructor());
+        x.find(overloaded_constructor(1))->second == overloaded_constructor());
 
       x.emplace(piecewise_rvalue(), boost::make_tuple(2, 3),
         boost::make_tuple(4, 5, 6));
@@ -1295,10 +1274,10 @@ UNORDERED_AUTO_TEST(map_emplace_test2)
                  x.find(overloaded_constructor(9, 3, 1))->second ==
                    overloaded_constructor(10));
     }
-}
+  }
 
-UNORDERED_AUTO_TEST(set_emplace_test2)
+  UNORDERED_AUTO_TEST(set_emplace_test2)
-{
+  {
     boost::unordered_set<
       std::pair<overloaded_constructor, overloaded_constructor> >
       x;
@@ -1314,7 +1293,7 @@ UNORDERED_AUTO_TEST(set_emplace_test2)
     check =
       std::make_pair(overloaded_constructor(1), overloaded_constructor(2, 3));
     BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
-}
+  }
 
 // Use the preprocessor to generate tests using different combinations of
 // boost/std piecewise_construct_t/tuple.
@@ -1377,15 +1356,15 @@ UNORDERED_AUTO_TEST(PIECEWISE_TEST_NAME)
 
     x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
       TUPLE_NAMESPACE::make_tuple(), TUPLE_NAMESPACE::make_tuple());
-        BOOST_TEST(x.find(overloaded_constructor()) != x.end() &&
+    BOOST_TEST(
-                   x.find(overloaded_constructor())->second ==
+      x.find(overloaded_constructor()) != x.end() &&
-                       overloaded_constructor());
+      x.find(overloaded_constructor())->second == overloaded_constructor());
 
     x.emplace(convertible_to_piecewise(), TUPLE_NAMESPACE::make_tuple(1),
       TUPLE_NAMESPACE::make_tuple());
-        BOOST_TEST(x.find(overloaded_constructor(1)) != x.end() &&
+    BOOST_TEST(
-                   x.find(overloaded_constructor(1))->second ==
+      x.find(overloaded_constructor(1)) != x.end() &&
-                       overloaded_constructor());
+      x.find(overloaded_constructor(1))->second == overloaded_constructor());
 
     x.emplace(piecewise_rvalue(), TUPLE_NAMESPACE::make_tuple(2, 3),
       TUPLE_NAMESPACE::make_tuple(4, 5, 6));
@@ -1394,8 +1373,8 @@ UNORDERED_AUTO_TEST(PIECEWISE_TEST_NAME)
                  overloaded_constructor(4, 5, 6));
 
     derived_from_piecewise_construct_t d;
-        x.emplace(d, TUPLE_NAMESPACE::make_tuple(9, 3, 1),
+    x.emplace(
-            TUPLE_NAMESPACE::make_tuple(10));
+      d, TUPLE_NAMESPACE::make_tuple(9, 3, 1), TUPLE_NAMESPACE::make_tuple(10));
     BOOST_TEST(x.find(overloaded_constructor(9, 3, 1)) != x.end() &&
                x.find(overloaded_constructor(9, 3, 1))->second ==
                  overloaded_constructor(10));
@@ -1403,14 +1382,14 @@ UNORDERED_AUTO_TEST(PIECEWISE_TEST_NAME)
     x.clear();
 
     x.try_emplace(overloaded_constructor());
-        BOOST_TEST(x.find(overloaded_constructor()) != x.end() &&
+    BOOST_TEST(
-                   x.find(overloaded_constructor())->second ==
+      x.find(overloaded_constructor()) != x.end() &&
-                       overloaded_constructor());
+      x.find(overloaded_constructor())->second == overloaded_constructor());
 
     x.try_emplace(1);
-        BOOST_TEST(x.find(overloaded_constructor(1)) != x.end() &&
+    BOOST_TEST(
-                   x.find(overloaded_constructor(1))->second ==
+      x.find(overloaded_constructor(1)) != x.end() &&
-                       overloaded_constructor());
+      x.find(overloaded_constructor(1))->second == overloaded_constructor());
 
     x.try_emplace(overloaded_constructor(2, 3), 4, 5, 6);
     BOOST_TEST(x.find(overloaded_constructor(2, 3)) != x.end() &&
@@ -1418,8 +1397,8 @@ UNORDERED_AUTO_TEST(PIECEWISE_TEST_NAME)
                  overloaded_constructor(4, 5, 6));
   }
   {
-        boost::unordered_multimap<overloaded_constructor,
+    boost::unordered_multimap<overloaded_constructor, overloaded_constructor,
-            overloaded_constructor, boost::hash<overloaded_constructor>,
+      boost::hash<overloaded_constructor>,
       std::equal_to<overloaded_constructor>,
       test::allocator1<std::pair<overloaded_constructor const,
         overloaded_constructor> > >
@@ -1427,15 +1406,15 @@ UNORDERED_AUTO_TEST(PIECEWISE_TEST_NAME)
 
     x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
       TUPLE_NAMESPACE::make_tuple(), TUPLE_NAMESPACE::make_tuple());
-        BOOST_TEST(x.find(overloaded_constructor()) != x.end() &&
+    BOOST_TEST(
-                   x.find(overloaded_constructor())->second ==
+      x.find(overloaded_constructor()) != x.end() &&
-                       overloaded_constructor());
+      x.find(overloaded_constructor())->second == overloaded_constructor());
 
     x.emplace(convertible_to_piecewise(), TUPLE_NAMESPACE::make_tuple(1),
       TUPLE_NAMESPACE::make_tuple());
-        BOOST_TEST(x.find(overloaded_constructor(1)) != x.end() &&
+    BOOST_TEST(
-                   x.find(overloaded_constructor(1))->second ==
+      x.find(overloaded_constructor(1)) != x.end() &&
-                       overloaded_constructor());
+      x.find(overloaded_constructor(1))->second == overloaded_constructor());
 
     x.emplace(piecewise_rvalue(), TUPLE_NAMESPACE::make_tuple(2, 3),
       TUPLE_NAMESPACE::make_tuple(4, 5, 6));
@@ -1444,8 +1423,8 @@ UNORDERED_AUTO_TEST(PIECEWISE_TEST_NAME)
                  overloaded_constructor(4, 5, 6));
 
     derived_from_piecewise_construct_t d;
-        x.emplace(d, TUPLE_NAMESPACE::make_tuple(9, 3, 1),
+    x.emplace(
-            TUPLE_NAMESPACE::make_tuple(10));
+      d, TUPLE_NAMESPACE::make_tuple(9, 3, 1), TUPLE_NAMESPACE::make_tuple(10));
     BOOST_TEST(x.find(overloaded_constructor(9, 3, 1)) != x.end() &&
                x.find(overloaded_constructor(9, 3, 1))->second ==
                  overloaded_constructor(10));

test/unordered/load_factor_tests.cpp

@@ -21,10 +21,10 @@
 
 namespace load_factor_tests {
 
-test::seed_t initialize_seed(783656);
+  test::seed_t initialize_seed(783656);
 
-template <class X> void set_load_factor_tests(X*)
+  template <class X> void set_load_factor_tests(X*)
-{
+  {
     X x;
 
     BOOST_TEST(x.max_load_factor() == 1.0);
@@ -36,11 +36,11 @@ template <class X> void set_load_factor_tests(X*)
     BOOST_TEST(x.max_load_factor() == 2.0);
     x.max_load_factor(0.5);
     BOOST_TEST(x.max_load_factor() == 0.5);
-}
+  }
 
-template <class X>
+  template <class X>
-void insert_test(X*, float mlf, test::random_generator generator)
+  void insert_test(X*, float mlf, test::random_generator generator)
-{
+  {
     X x;
     x.max_load_factor(mlf);
     float b = x.max_load_factor();
@@ -58,11 +58,11 @@ void insert_test(X*, float mlf, test::random_generator generator)
           b * static_cast<double>(old_bucket_count))
         BOOST_TEST(x.bucket_count() == old_bucket_count);
     }
-}
+  }
 
-template <class X>
+  template <class X>
-void load_factor_insert_tests(X* ptr, test::random_generator generator)
+  void load_factor_insert_tests(X* ptr, test::random_generator generator)
-{
+  {
     insert_test(ptr, 1.0f, generator);
     insert_test(ptr, 0.1f, generator);
     insert_test(ptr, 100.0f, generator);
@@ -71,21 +71,21 @@ void load_factor_insert_tests(X* ptr, test::random_generator generator)
 
     if (std::numeric_limits<float>::has_infinity)
       insert_test(ptr, std::numeric_limits<float>::infinity(), generator);
-}
+  }
 
-boost::unordered_set<int>* int_set_ptr;
+  boost::unordered_set<int>* int_set_ptr;
-boost::unordered_multiset<int>* int_multiset_ptr;
+  boost::unordered_multiset<int>* int_multiset_ptr;
-boost::unordered_map<int, int>* int_map_ptr;
+  boost::unordered_map<int, int>* int_map_ptr;
-boost::unordered_multimap<int, int>* int_multimap_ptr;
+  boost::unordered_multimap<int, int>* int_multimap_ptr;
 
-using test::default_generator;
+  using test::default_generator;
-using test::generate_collisions;
+  using test::generate_collisions;
-using test::limited_range;
+  using test::limited_range;
 
-UNORDERED_TEST(set_load_factor_tests,
+  UNORDERED_TEST(set_load_factor_tests,
     ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr)))
 
-UNORDERED_TEST(load_factor_insert_tests,
+  UNORDERED_TEST(load_factor_insert_tests,
     ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr))(
                    (default_generator)(generate_collisions)(limited_range)))
 }

test/unordered/merge_tests.cpp

@@ -19,8 +19,8 @@
 
 namespace merge_tests {
 
-UNORDERED_AUTO_TEST(merge_set)
+  UNORDERED_AUTO_TEST(merge_set)
-{
+  {
     boost::unordered_set<int> x;
     boost::unordered_set<int> y;
 
@@ -57,10 +57,10 @@ UNORDERED_AUTO_TEST(merge_set)
 
     test::check_equivalent_keys(x);
     test::check_equivalent_keys(y);
-}
+  }
 
-UNORDERED_AUTO_TEST(merge_multiset)
+  UNORDERED_AUTO_TEST(merge_multiset)
-{
+  {
     boost::unordered_multiset<int> x;
     boost::unordered_multiset<int> y;
 
@@ -97,10 +97,10 @@ UNORDERED_AUTO_TEST(merge_multiset)
 
     test::check_equivalent_keys(x);
     test::check_equivalent_keys(y);
-}
+  }
 
-UNORDERED_AUTO_TEST(merge_set_and_multiset)
+  UNORDERED_AUTO_TEST(merge_set_and_multiset)
-{
+  {
     boost::unordered_set<int> x;
     boost::unordered_multiset<int> y;
 
@@ -137,11 +137,11 @@ UNORDERED_AUTO_TEST(merge_set_and_multiset)
 
     test::check_equivalent_keys(x);
     test::check_equivalent_keys(y);
-}
+  }
 
-template <class X1, class X2>
+  template <class X1, class X2>
-void merge_empty_test(X1*, X2*, test::random_generator generator)
+  void merge_empty_test(X1*, X2*, test::random_generator generator)
-{
+  {
     test::check_instances check_;
 
     test::random_values<X1> v(1000, generator);
@@ -152,11 +152,11 @@ void merge_empty_test(X1*, X2*, test::random_generator generator)
     BOOST_TEST(x2.empty());
     test::check_equivalent_keys(x1);
     test::check_equivalent_keys(x2);
-}
+  }
 
-template <class X>
+  template <class X>
-void merge_into_empty_test(X*, test::random_generator generator)
+  void merge_into_empty_test(X*, test::random_generator generator)
-{
+  {
     test::check_instances check_;
 
     test::random_values<X> v(1000, generator);
@@ -167,12 +167,12 @@ void merge_into_empty_test(X*, test::random_generator generator)
     BOOST_TEST(x2.empty());
     test::check_equivalent_keys(x1);
     test::check_equivalent_keys(x2);
-}
+  }
 
-template <class X1, class X2>
+  template <class X1, class X2>
-void merge_into_unique_keys_test(X1*, X2*, int hash_equal1, int hash_equal2,
+  void merge_into_unique_keys_test(X1*, X2*, int hash_equal1, int hash_equal2,
     test::random_generator generator)
-{
+  {
     test::check_instances check_;
 
     test::random_values<X1> v1(1000, generator);
@@ -200,12 +200,12 @@ void merge_into_unique_keys_test(X1*, X2*, int hash_equal1, int hash_equal2,
     tracker2.compare(x2);
     test::check_equivalent_keys(x1);
     test::check_equivalent_keys(x2);
-}
+  }
 
-template <class X1, class X2>
+  template <class X1, class X2>
-void merge_into_equiv_keys_test(X1*, X2*, int hash_equal1, int hash_equal2,
+  void merge_into_equiv_keys_test(X1*, X2*, int hash_equal1, int hash_equal2,
     test::random_generator generator)
-{
+  {
     test::check_instances check_;
 
     test::random_values<X1> v1(1000, generator);
@@ -230,32 +230,32 @@ void merge_into_equiv_keys_test(X1*, X2*, int hash_equal1, int hash_equal2,
     tracker2.compare(x2);
     test::check_equivalent_keys(x1);
     test::check_equivalent_keys(x2);
-}
+  }
 
-boost::unordered_set<test::movable, test::hash, test::equal_to,
+  boost::unordered_set<test::movable, test::hash, test::equal_to,
     std::allocator<test::movable> >* test_set_std_alloc;
-boost::unordered_multiset<test::movable, test::hash, test::equal_to,
+  boost::unordered_multiset<test::movable, test::hash, test::equal_to,
     std::allocator<test::movable> >* test_multiset_std_alloc;
 
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     std::allocator<test::object> >* test_map_std_alloc;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, std::allocator<test::object> >* test_multimap_std_alloc;
 
-boost::unordered_set<test::object, test::hash, test::equal_to,
+  boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
-boost::unordered_multiset<test::object, test::hash, test::equal_to,
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_multiset;
 
-boost::unordered_map<test::movable, test::movable, test::hash, test::equal_to,
+  boost::unordered_map<test::movable, test::movable, test::hash, test::equal_to,
     test::allocator2<test::movable> >* test_map;
-boost::unordered_multimap<test::movable, test::movable, test::hash,
+  boost::unordered_multimap<test::movable, test::movable, test::hash,
     test::equal_to, test::allocator2<test::movable> >* test_multimap;
 
-using test::default_generator;
+  using test::default_generator;
-using test::generate_collisions;
+  using test::generate_collisions;
 
-// clang-format off
+  // clang-format off
 UNORDERED_TEST(merge_empty_test,
     ((test_set_std_alloc)(test_multiset_std_alloc))
     ((test_set_std_alloc)(test_multiset_std_alloc))
@@ -335,7 +335,7 @@ UNORDERED_TEST(merge_into_equiv_keys_test,
     ((0)(1)(2))
     ((0)(1)(2))
     ((default_generator)(generate_collisions)))
-// clang-format on
+  // clang-format on
 }
 
 RUN_TESTS()

test/unordered/minimal_allocator.cpp

@@ -35,8 +35,7 @@ template <typename T> void test_simple_allocator()
   BOOST_STATIC_ASSERT((boost::is_same<typename traits::allocator_type,
     SimpleAllocator<T> >::value));
 
-    BOOST_STATIC_ASSERT(
+  BOOST_STATIC_ASSERT((boost::is_same<typename traits::value_type, T>::value));
-        (boost::is_same<typename traits::value_type, T>::value));
 
   BOOST_STATIC_ASSERT((boost::is_same<typename traits::pointer, T*>::value));
   BOOST_STATIC_ASSERT(
@@ -46,8 +45,8 @@ template <typename T> void test_simple_allocator()
   // BOOST_STATIC_ASSERT((boost::is_same<typename traits::const_void_pointer,
   // void const*>::value));
 
-    BOOST_STATIC_ASSERT((boost::is_same<typename traits::difference_type,
+  BOOST_STATIC_ASSERT(
-        std::ptrdiff_t>::value));
+    (boost::is_same<typename traits::difference_type, std::ptrdiff_t>::value));
 
 #if BOOST_UNORDERED_USE_ALLOCATOR_TRAITS == 1
   BOOST_STATIC_ASSERT((boost::is_same<typename traits::size_type,

test/unordered/move_tests.cpp

@@ -23,7 +23,7 @@
 #endif
 
 namespace move_tests {
-test::seed_t initialize_seed(98624);
+  test::seed_t initialize_seed(98624);
 #if defined(BOOST_UNORDERED_USE_MOVE) ||                                       \
   !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 #define BOOST_UNORDERED_TEST_MOVING 1
@@ -31,31 +31,31 @@ test::seed_t initialize_seed(98624);
 #define BOOST_UNORDERED_TEST_MOVING 0
 #endif
 
-template <class T> T empty(T*) { return T(); }
+  template <class T> T empty(T*) { return T(); }
 
-template <class T>
+  template <class T>
-T create(test::random_values<T> const& v, test::object_count& count)
+  T create(test::random_values<T> const& v, test::object_count& count)
-{
+  {
     T x(v.begin(), v.end());
     count = test::global_object_count;
     return x;
-}
+  }
 
-template <class T>
+  template <class T>
-T create(test::random_values<T> const& v, test::object_count& count,
+  T create(test::random_values<T> const& v, test::object_count& count,
     BOOST_DEDUCED_TYPENAME T::hasher hf, BOOST_DEDUCED_TYPENAME T::key_equal eq,
     BOOST_DEDUCED_TYPENAME T::allocator_type al, float mlf)
-{
+  {
     T x(0, hf, eq, al);
     x.max_load_factor(mlf);
     x.insert(v.begin(), v.end());
     count = test::global_object_count;
     return x;
-}
+  }
 
-template <class T>
+  template <class T>
-void move_construct_tests1(T* ptr, test::random_generator const& generator)
+  void move_construct_tests1(T* ptr, test::random_generator const& generator)
-{
+  {
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::key_equal eq;
     BOOST_DEDUCED_TYPENAME T::allocator_type al;
@@ -84,11 +84,11 @@ void move_construct_tests1(T* ptr, test::random_generator const& generator)
       test::check_container(y, v);
       test::check_equivalent_keys(y);
     }
-}
+  }
 
-template <class T>
+  template <class T>
-void move_assign_tests1(T*, test::random_generator const& generator)
+  void move_assign_tests1(T*, test::random_generator const& generator)
-{
+  {
     {
       test::check_instances check_;
 
@@ -102,11 +102,11 @@ void move_assign_tests1(T*, test::random_generator const& generator)
       test::check_container(y, v);
       test::check_equivalent_keys(y);
     }
-}
+  }
 
-template <class T>
+  template <class T>
-void move_construct_tests2(T*, test::random_generator const& generator)
+  void move_construct_tests2(T*, test::random_generator const& generator)
-{
+  {
     BOOST_DEDUCED_TYPENAME T::hasher hf(1);
     BOOST_DEDUCED_TYPENAME T::key_equal eq(1);
     BOOST_DEDUCED_TYPENAME T::allocator_type al(1);
@@ -155,15 +155,15 @@ void move_construct_tests2(T*, test::random_generator const& generator)
       BOOST_TEST(count == test::global_object_count);
 #elif defined(BOOST_HAS_NRVO)
       BOOST_TEST(
-            static_cast<std::size_t>(test::global_object_count.constructions -
+        static_cast<std::size_t>(
-                                     count.constructions) <=
+          test::global_object_count.constructions - count.constructions) <=
         (test::is_set<T>::value ? 1 : 2) *
           (test::has_unique_keys<T>::value ? 25 : v.size()));
       BOOST_TEST(count.instances == test::global_object_count.instances);
 #else
       BOOST_TEST(
-            static_cast<std::size_t>(test::global_object_count.constructions -
+        static_cast<std::size_t>(
-                                     count.constructions) <=
+          test::global_object_count.constructions - count.constructions) <=
         (test::is_set<T>::value ? 2 : 4) *
           (test::has_unique_keys<T>::value ? 25 : v.size()));
       BOOST_TEST(count.instances == test::global_object_count.instances);
@@ -175,11 +175,11 @@ void move_construct_tests2(T*, test::random_generator const& generator)
       BOOST_TEST(y.max_load_factor() == 1.0); // Not necessarily required.
       test::check_equivalent_keys(y);
     }
-}
+  }
 
-template <class T>
+  template <class T>
-void move_assign_tests2(T*, test::random_generator const& generator)
+  void move_assign_tests2(T*, test::random_generator const& generator)
-{
+  {
     BOOST_DEDUCED_TYPENAME T::hasher hf(1);
     BOOST_DEDUCED_TYPENAME T::key_equal eq(1);
     BOOST_DEDUCED_TYPENAME T::allocator_type al1(1);
@@ -214,8 +214,7 @@ void move_assign_tests2(T*, test::random_generator const& generator)
       T y(0, hf, eq, al1);
       y = create(v, count, hf, eq, al2, 0.5);
 #if defined(BOOST_HAS_NRVO)
-        if (BOOST_UNORDERED_TEST_MOVING &&
+      if (BOOST_UNORDERED_TEST_MOVING && allocator_type::is_propagate_on_move) {
-            allocator_type::is_propagate_on_move) {
         BOOST_TEST(count == test::global_object_count);
       }
 #endif
@@ -246,8 +245,7 @@ void move_assign_tests2(T*, test::random_generator const& generator)
 
       test::object_count count = test::global_object_count;
       y = boost::move(x);
-        if (BOOST_UNORDERED_TEST_MOVING &&
+      if (BOOST_UNORDERED_TEST_MOVING && allocator_type::is_propagate_on_move) {
-            allocator_type::is_propagate_on_move) {
         BOOST_TEST(count == test::global_object_count);
       }
       test::check_container(y, v);
@@ -280,11 +278,10 @@ void move_assign_tests2(T*, test::random_generator const& generator)
 
       test::object_count count2 = test::global_object_count;
 
-        if (BOOST_UNORDERED_TEST_MOVING &&
+      if (BOOST_UNORDERED_TEST_MOVING && allocator_type::is_propagate_on_move) {
-            allocator_type::is_propagate_on_move) {
         BOOST_TEST(count1.instances == test::global_object_count.instances);
-            BOOST_TEST(count2.constructions ==
+        BOOST_TEST(
-                       test::global_object_count.constructions);
+          count2.constructions == test::global_object_count.constructions);
       }
 
       test::check_container(y, v2);
@@ -299,76 +296,76 @@ void move_assign_tests2(T*, test::random_generator const& generator)
         BOOST_TEST(test::equivalent(y.get_allocator(), al1));
       }
     }
-}
+  }
 
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     std::allocator<test::object> >* test_map_std_alloc;
 
-boost::unordered_set<test::object, test::hash, test::equal_to,
+  boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_set;
-boost::unordered_multiset<test::object, test::hash, test::equal_to,
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, test::allocator2<test::object> >* test_multimap;
 
-boost::unordered_set<test::object, test::hash, test::equal_to,
+  boost::unordered_set<test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::propagate_move> >*
     test_set_prop_move;
-boost::unordered_multiset<test::object, test::hash, test::equal_to,
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::propagate_move> >*
     test_multiset_prop_move;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::propagate_move> >*
     test_map_prop_move;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, test::cxx11_allocator<test::object, test::propagate_move> >*
     test_multimap_prop_move;
 
-boost::unordered_set<test::object, test::hash, test::equal_to,
+  boost::unordered_set<test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::no_propagate_move> >*
     test_set_no_prop_move;
-boost::unordered_multiset<test::object, test::hash, test::equal_to,
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::no_propagate_move> >*
     test_multiset_no_prop_move;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::no_propagate_move> >*
     test_map_no_prop_move;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to,
     test::cxx11_allocator<test::object, test::no_propagate_move> >*
     test_multimap_no_prop_move;
 
-using test::default_generator;
+  using test::default_generator;
-using test::generate_collisions;
+  using test::generate_collisions;
-using test::limited_range;
+  using test::limited_range;
 
-UNORDERED_TEST(move_construct_tests1,
+  UNORDERED_TEST(move_construct_tests1,
     ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap)(
       test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(
       test_multimap_prop_move)(test_set_no_prop_move)(
       test_multiset_no_prop_move)(test_map_no_prop_move)(
       test_multimap_no_prop_move))(
                    (default_generator)(generate_collisions)(limited_range)))
-UNORDERED_TEST(move_assign_tests1,
+  UNORDERED_TEST(move_assign_tests1,
     ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap)(
       test_set_prop_move)(test_multiset_prop_move)(test_map_prop_move)(
       test_multimap_prop_move)(test_set_no_prop_move)(
       test_multiset_no_prop_move)(test_map_no_prop_move)(
       test_multimap_no_prop_move))(
                    (default_generator)(generate_collisions)(limited_range)))
-UNORDERED_TEST(move_construct_tests2,
+  UNORDERED_TEST(move_construct_tests2,
     ((test_set)(test_multiset)(test_map)(test_multimap)(test_set_prop_move)(
       test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)(
-        test_set_no_prop_move)(test_multiset_no_prop_move)(
+      test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(
-        test_map_no_prop_move)(test_multimap_no_prop_move))(
+      test_multimap_no_prop_move))(
                    (default_generator)(generate_collisions)(limited_range)))
-UNORDERED_TEST(move_assign_tests2,
+  UNORDERED_TEST(move_assign_tests2,
     ((test_set)(test_multiset)(test_map)(test_multimap)(test_set_prop_move)(
       test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)(
-        test_set_no_prop_move)(test_multiset_no_prop_move)(
+      test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(
-        test_map_no_prop_move)(test_multimap_no_prop_move))(
+      test_multimap_no_prop_move))(
                    (default_generator)(generate_collisions)(limited_range)))
 }
 

test/unordered/node_handle_tests.cpp

@@ -149,8 +149,8 @@ UNORDERED_AUTO_TEST(failed_insertion_with_hint)
 }
 
 template <typename NodeHandle>
-bool node_handle_compare(NodeHandle const& nh,
+bool node_handle_compare(
-    BOOST_DEDUCED_TYPENAME NodeHandle::value_type const& x)
+  NodeHandle const& nh, BOOST_DEDUCED_TYPENAME NodeHandle::value_type const& x)
 {
   return x == nh.value();
 }
@@ -287,8 +287,8 @@ void insert_node_handle_unique(Container1& c1, Container2& c2)
       BOOST_TEST(!r.inserted);
       BOOST_TEST_EQ(c2.count(test::get_key<Container1>(v)), count);
       BOOST_TEST(r.position != c2.end());
-            BOOST_TEST(test::get_key<Container2>(*r.position) ==
+      BOOST_TEST(
-                       test::get_key<Container2>(v));
+        test::get_key<Container2>(*r.position) == test::get_key<Container2>(v));
       BOOST_TEST(r.node);
       node_handle_compare(r.node, v);
     }
@@ -312,8 +312,7 @@ void insert_node_handle_unique2(Container1& c1, Container2& c2)
     value_type v = *c1.begin();
     value_type const* v_ptr = boost::addressof(*c1.begin());
     std::size_t count = c2.count(test::get_key<Container1>(v));
-        insert_return_type2 r =
+    insert_return_type2 r = c2.insert(c1.extract(test::get_key<Container1>(v)));
-            c2.insert(c1.extract(test::get_key<Container1>(v)));
     if (r.inserted) {
       BOOST_TEST_EQ(c2.count(test::get_key<Container1>(v)), count + 1);
       BOOST_TEST(r.position != c2.end());
@@ -322,8 +321,8 @@ void insert_node_handle_unique2(Container1& c1, Container2& c2)
     } else {
       BOOST_TEST_EQ(c2.count(test::get_key<Container1>(v)), count);
       BOOST_TEST(r.position != c2.end());
-            BOOST_TEST(test::get_key<Container2>(*r.position) ==
+      BOOST_TEST(
-                       test::get_key<Container2>(v));
+        test::get_key<Container2>(*r.position) == test::get_key<Container2>(v));
       BOOST_TEST(r.node);
       node_handle_compare(r.node, v);
     }

test/unordered/noexcept_tests.cpp

@@ -13,37 +13,37 @@
 #include "../helpers/test.hpp"
 
 namespace noexcept_tests {
-// Test the noexcept is set correctly for the move constructor.
+  // Test the noexcept is set correctly for the move constructor.
 
-struct hash_possible_exception : boost::hash<int>
+  struct hash_possible_exception : boost::hash<int>
-{
+  {
     hash_possible_exception(hash_possible_exception const&) {}
-};
+  };
 
-struct equal_to_possible_exception : std::equal_to<int>
+  struct equal_to_possible_exception : std::equal_to<int>
-{
+  {
     equal_to_possible_exception(equal_to_possible_exception const&) {}
-};
+  };
 
-// Test that the move constructor does actually move without throwing
+  // Test that the move constructor does actually move without throwing
-// an exception when it claims to.
+  // an exception when it claims to.
 
-struct test_exception
+  struct test_exception
-{
+  {
-};
+  };
 
-bool throwing_test_exception = false;
+  bool throwing_test_exception = false;
-void test_throw(char const* name)
+  void test_throw(char const* name)
-{
+  {
     if (throwing_test_exception) {
       BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Throw exception in: " << name
                                      << std::endl;
       throw test_exception();
     }
-}
+  }
 
-class hash_nothrow_move : boost::hash<int>
+  class hash_nothrow_move : boost::hash<int>
-{
+  {
     BOOST_COPYABLE_AND_MOVABLE(hash_nothrow_move)
 
     typedef boost::hash<int> base;
@@ -68,10 +68,10 @@ class hash_nothrow_move : boost::hash<int>
       test_throw("Operator");
       return static_cast<base const&>(*this)(x);
     }
-};
+  };
 
-class equal_to_nothrow_move : std::equal_to<int>
+  class equal_to_nothrow_move : std::equal_to<int>
-{
+  {
     BOOST_COPYABLE_AND_MOVABLE(equal_to_nothrow_move)
 
     typedef std::equal_to<int> base;
@@ -96,12 +96,12 @@ class equal_to_nothrow_move : std::equal_to<int>
       test_throw("Operator");
       return static_cast<base const&>(*this)(x, y);
     }
-};
+  };
 
-bool have_is_nothrow_move = false;
+  bool have_is_nothrow_move = false;
 
-UNORDERED_AUTO_TEST(check_is_nothrow_move)
+  UNORDERED_AUTO_TEST(check_is_nothrow_move)
-{
+  {
     BOOST_TEST(
       !boost::is_nothrow_move_constructible<hash_possible_exception>::value);
     have_is_nothrow_move =
@@ -117,10 +117,10 @@ UNORDERED_AUTO_TEST(check_is_nothrow_move)
   !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40800)
     BOOST_TEST(have_is_nothrow_move);
 #endif
-}
+  }
 
-UNORDERED_AUTO_TEST(test_noexcept)
+  UNORDERED_AUTO_TEST(test_noexcept)
-{
+  {
     if (have_is_nothrow_move) {
       BOOST_TEST((boost::is_nothrow_move_constructible<
         boost::unordered_set<int> >::value));
@@ -137,10 +137,10 @@ UNORDERED_AUTO_TEST(test_noexcept)
     BOOST_TEST(
       (!boost::is_nothrow_move_constructible<boost::unordered_multiset<int,
           boost::hash<int>, equal_to_possible_exception> >::value));
-}
+  }
 
-UNORDERED_AUTO_TEST(test_no_throw_when_noexcept)
+  UNORDERED_AUTO_TEST(test_no_throw_when_noexcept)
-{
+  {
     typedef boost::unordered_set<int, hash_nothrow_move, equal_to_nothrow_move>
       throwing_set;
 
@@ -165,7 +165,7 @@ UNORDERED_AUTO_TEST(test_no_throw_when_noexcept)
 
       throwing_test_exception = false;
     }
-}
+  }
 }
 
 RUN_TESTS()

test/unordered/rehash_tests.cpp

@@ -18,18 +18,18 @@
 
 namespace rehash_tests {
 
-test::seed_t initialize_seed(2974);
+  test::seed_t initialize_seed(2974);
 
-template <class X>
+  template <class X>
-bool postcondition(X const& x, BOOST_DEDUCED_TYPENAME X::size_type n)
+  bool postcondition(X const& x, BOOST_DEDUCED_TYPENAME X::size_type n)
-{
+  {
     return static_cast<double>(x.bucket_count()) >=
              static_cast<double>(x.size()) / x.max_load_factor() &&
            x.bucket_count() >= n;
-}
+  }
 
-template <class X> void rehash_empty_test1(X*)
+  template <class X> void rehash_empty_test1(X*)
-{
+  {
     X x;
 
     x.rehash(10000);
@@ -40,10 +40,11 @@ template <class X> void rehash_empty_test1(X*)
 
     x.rehash(10000000);
     BOOST_TEST(postcondition(x, 10000000));
-}
+  }
 
-template <class X> void rehash_empty_test2(X*, test::random_generator generator)
+  template <class X>
-{
+  void rehash_empty_test2(X*, test::random_generator generator)
+  {
     test::random_values<X> v(1000, generator);
     test::ordered<X> tracker;
 
@@ -61,10 +62,11 @@ template <class X> void rehash_empty_test2(X*, test::random_generator generator)
     x.rehash(10000000);
     tracker.compare(x);
     BOOST_TEST(postcondition(x, 10000000));
-}
+  }
 
-template <class X> void rehash_empty_test3(X*, test::random_generator generator)
+  template <class X>
-{
+  void rehash_empty_test3(X*, test::random_generator generator)
+  {
     test::random_values<X> v(1000, generator);
     test::ordered<X> tracker;
 
@@ -78,10 +80,10 @@ template <class X> void rehash_empty_test3(X*, test::random_generator generator)
     tracker.compare(x);
 
     BOOST_TEST(postcondition(x, 0));
-}
+  }
 
-template <class X> void rehash_test1(X*, test::random_generator generator)
+  template <class X> void rehash_test1(X*, test::random_generator generator)
-{
+  {
     test::random_values<X> v(1000, generator);
     test::ordered<X> tracker;
     tracker.insert_range(v.begin(), v.end());
@@ -104,10 +106,10 @@ template <class X> void rehash_test1(X*, test::random_generator generator)
     x.rehash(1000);
     BOOST_TEST(postcondition(x, 1000));
     tracker.compare(x);
-}
+  }
 
-template <class X> void reserve_empty_test1(X*)
+  template <class X> void reserve_empty_test1(X*)
-{
+  {
     X x;
 
     x.reserve(10000);
@@ -117,10 +119,10 @@ template <class X> void reserve_empty_test1(X*)
 
     x.reserve(10000000);
     BOOST_TEST(x.bucket_count() >= 10000000);
-}
+  }
 
-template <class X> void reserve_empty_test2(X*)
+  template <class X> void reserve_empty_test2(X*)
-{
+  {
     X x;
     x.max_load_factor(0.25);
 
@@ -131,10 +133,10 @@ template <class X> void reserve_empty_test2(X*)
 
     x.reserve(10000000);
     BOOST_TEST(x.bucket_count() >= 40000000);
-}
+  }
 
-template <class X> void reserve_test1(X*, test::random_generator generator)
+  template <class X> void reserve_test1(X*, test::random_generator generator)
-{
+  {
     for (int random_mlf = 0; random_mlf < 2; ++random_mlf) {
       for (std::size_t i = 1; i < 2000; i += i < 50 ? 1 : 13) {
         test::random_values<X> v(i, generator);
@@ -144,8 +146,7 @@ template <class X> void reserve_test1(X*, test::random_generator generator)
 
         X x;
         x.max_load_factor(
-                random_mlf
+          random_mlf ? static_cast<float>(std::rand() % 1000) / 500.0f + 0.5f
-                    ? static_cast<float>(std::rand() % 1000) / 500.0f + 0.5f
                      : 1.0f);
         x.reserve(test::has_unique_keys<X>::value ? i : v.size());
 
@@ -162,10 +163,10 @@ template <class X> void reserve_test1(X*, test::random_generator generator)
         tracker.compare(x);
       }
     }
-}
+  }
 
-template <class X> void reserve_test2(X*, test::random_generator generator)
+  template <class X> void reserve_test2(X*, test::random_generator generator)
-{
+  {
     for (int random_mlf = 0; random_mlf < 2; ++random_mlf) {
       for (std::size_t i = 0; i < 2000; i += i < 50 ? 1 : 13) {
         test::random_values<X> v(i, generator);
@@ -175,8 +176,7 @@ template <class X> void reserve_test2(X*, test::random_generator generator)
 
         X x;
         x.max_load_factor(
-                random_mlf
+          random_mlf ? static_cast<float>(std::rand() % 1000) / 500.0f + 0.5f
-                    ? static_cast<float>(std::rand() % 1000) / 500.0f + 0.5f
                      : 1.0f);
 
         x.reserve(test::has_unique_keys<X>::value ? i : v.size());
@@ -191,38 +191,38 @@ template <class X> void reserve_test2(X*, test::random_generator generator)
         tracker.compare(x);
       }
     }
-}
+  }
 
-boost::unordered_set<int>* int_set_ptr;
+  boost::unordered_set<int>* int_set_ptr;
-boost::unordered_multiset<test::object, test::hash, test::equal_to,
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_multiset_ptr;
-boost::unordered_map<test::movable, test::movable, test::hash, test::equal_to,
+  boost::unordered_map<test::movable, test::movable, test::hash, test::equal_to,
     test::allocator2<test::movable> >* test_map_ptr;
-boost::unordered_multimap<int, int>* int_multimap_ptr;
+  boost::unordered_multimap<int, int>* int_multimap_ptr;
 
-using test::default_generator;
+  using test::default_generator;
-using test::generate_collisions;
+  using test::generate_collisions;
-using test::limited_range;
+  using test::limited_range;
 
-UNORDERED_TEST(rehash_empty_test1,
+  UNORDERED_TEST(rehash_empty_test1,
     ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr)))
-UNORDERED_TEST(rehash_empty_test2,
+  UNORDERED_TEST(rehash_empty_test2,
     ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))(
                    (default_generator)(generate_collisions)(limited_range)))
-UNORDERED_TEST(rehash_empty_test3,
+  UNORDERED_TEST(rehash_empty_test3,
     ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))(
                    (default_generator)(generate_collisions)(limited_range)))
-UNORDERED_TEST(rehash_test1,
+  UNORDERED_TEST(rehash_test1,
     ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))(
                    (default_generator)(generate_collisions)(limited_range)))
-UNORDERED_TEST(reserve_empty_test1,
+  UNORDERED_TEST(reserve_empty_test1,
     ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr)))
-UNORDERED_TEST(reserve_empty_test2,
+  UNORDERED_TEST(reserve_empty_test2,
     ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr)))
-UNORDERED_TEST(reserve_test1,
+  UNORDERED_TEST(reserve_test1,
     ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))(
                    (default_generator)(generate_collisions)(limited_range)))
-UNORDERED_TEST(reserve_test2,
+  UNORDERED_TEST(reserve_test2,
     ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr))(
                    (default_generator)(generate_collisions)(limited_range)))
 }

test/unordered/swap_tests.cpp

@@ -26,10 +26,10 @@
 
 namespace swap_tests {
 
-test::seed_t initialize_seed(783472);
+  test::seed_t initialize_seed(783472);
 
-template <class X> void swap_test_impl(X& x1, X& x2)
+  template <class X> void swap_test_impl(X& x1, X& x2)
-{
+  {
     test::ordered<X> tracker1 = test::create_ordered(x1);
     test::ordered<X> tracker2 = test::create_ordered(x2);
     tracker1.insert_range(x1.begin(), x1.end());
@@ -37,10 +37,10 @@ template <class X> void swap_test_impl(X& x1, X& x2)
     x1.swap(x2);
     tracker1.compare(x2);
     tracker2.compare(x1);
-}
+  }
 
-template <class X> void swap_tests1(X*, test::random_generator generator)
+  template <class X> void swap_tests1(X*, test::random_generator generator)
-{
+  {
     {
       test::check_instances check_;
 
@@ -72,10 +72,10 @@ template <class X> void swap_tests1(X*, test::random_generator generator)
       swap_test_impl(x, y);
       swap_test_impl(x, y);
     }
-}
+  }
 
-template <class X> void swap_tests2(X* ptr, test::random_generator generator)
+  template <class X> void swap_tests2(X* ptr, test::random_generator generator)
-{
+  {
     swap_tests1(ptr, generator);
 
     typedef BOOST_DEDUCED_TYPENAME X::hasher hasher;
@@ -110,8 +110,7 @@ template <class X> void swap_tests2(X* ptr, test::random_generator generator)
     }
 
     {
-        test::force_equal_allocator force_(
+      test::force_equal_allocator force_(!allocator_type::is_propagate_on_swap);
-            !allocator_type::is_propagate_on_swap);
       test::check_instances check_;
 
       test::random_values<X> vx(50, generator), vy(100, generator);
@@ -125,15 +124,12 @@ template <class X> void swap_tests2(X* ptr, test::random_generator generator)
     }
 
     {
-        test::force_equal_allocator force_(
+      test::force_equal_allocator force_(!allocator_type::is_propagate_on_swap);
-            !allocator_type::is_propagate_on_swap);
       test::check_instances check_;
 
       test::random_values<X> vx(100, generator), vy(100, generator);
-        X x(vx.begin(), vx.end(), 0, hasher(1), key_equal(1),
+      X x(vx.begin(), vx.end(), 0, hasher(1), key_equal(1), allocator_type(1));
-            allocator_type(1));
+      X y(vy.begin(), vy.end(), 0, hasher(2), key_equal(2), allocator_type(2));
-        X y(vy.begin(), vy.end(), 0, hasher(2), key_equal(2),
-            allocator_type(2));
 
       if (allocator_type::is_propagate_on_swap ||
           x.get_allocator() == y.get_allocator()) {
@@ -141,76 +137,76 @@ template <class X> void swap_tests2(X* ptr, test::random_generator generator)
         swap_test_impl(x, y);
       }
     }
-}
+  }
 
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     std::allocator<test::object> >* test_map_std_alloc;
 
-boost::unordered_set<test::object, test::hash, test::equal_to,
+  boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
-boost::unordered_multiset<test::object, test::hash, test::equal_to,
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_multiset;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_map;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, test::allocator2<test::object> >* test_multimap;
 
-boost::unordered_set<test::object, test::hash, test::equal_to,
+  boost::unordered_set<test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::propagate_swap> >*
     test_set_prop_swap;
-boost::unordered_multiset<test::object, test::hash, test::equal_to,
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::propagate_swap> >*
     test_multiset_prop_swap;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::propagate_swap> >*
     test_map_prop_swap;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, test::cxx11_allocator<test::object, test::propagate_swap> >*
     test_multimap_prop_swap;
 
-boost::unordered_set<test::object, test::hash, test::equal_to,
+  boost::unordered_set<test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::no_propagate_swap> >*
     test_set_no_prop_swap;
-boost::unordered_multiset<test::object, test::hash, test::equal_to,
+  boost::unordered_multiset<test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::no_propagate_swap> >*
     test_multiset_no_prop_swap;
-boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
+  boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::no_propagate_swap> >*
     test_map_no_prop_swap;
-boost::unordered_multimap<test::object, test::object, test::hash,
+  boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to,
     test::cxx11_allocator<test::object, test::no_propagate_swap> >*
     test_multimap_no_prop_swap;
 
-template <typename T> bool is_propagate(T*)
+  template <typename T> bool is_propagate(T*)
-{
+  {
     return T::allocator_type::is_propagate_on_swap;
-}
+  }
 
-using test::default_generator;
+  using test::default_generator;
-using test::generate_collisions;
+  using test::generate_collisions;
-using test::limited_range;
+  using test::limited_range;
 
-UNORDERED_AUTO_TEST(check_traits)
+  UNORDERED_AUTO_TEST(check_traits)
-{
+  {
     BOOST_TEST(!is_propagate(test_set));
     BOOST_TEST(is_propagate(test_set_prop_swap));
     BOOST_TEST(!is_propagate(test_set_no_prop_swap));
-}
+  }
 
-UNORDERED_TEST(swap_tests1,
+  UNORDERED_TEST(
-    ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(test_multimap)(
+    swap_tests1, ((test_map_std_alloc)(test_set)(test_multiset)(test_map)(
-        test_set_prop_swap)(test_multiset_prop_swap)(test_map_prop_swap)(
+                   test_multimap)(test_set_prop_swap)(test_multiset_prop_swap)(
-        test_multimap_prop_swap)(test_set_no_prop_swap)(
+                   test_map_prop_swap)(test_multimap_prop_swap)(
-        test_multiset_no_prop_swap)(test_map_no_prop_swap)(
-        test_multimap_no_prop_swap))(
-                   (default_generator)(generate_collisions)(limited_range)))
-
-UNORDERED_TEST(swap_tests2,
-    ((test_set)(test_multiset)(test_map)(test_multimap)(test_set_prop_swap)(
-        test_multiset_prop_swap)(test_map_prop_swap)(test_multimap_prop_swap)(
                    test_set_no_prop_swap)(test_multiset_no_prop_swap)(
                    test_map_no_prop_swap)(test_multimap_no_prop_swap))(
                    (default_generator)(generate_collisions)(limited_range)))
+
+  UNORDERED_TEST(swap_tests2,
+    ((test_set)(test_multiset)(test_map)(test_multimap)(test_set_prop_swap)(
+      test_multiset_prop_swap)(test_map_prop_swap)(test_multimap_prop_swap)(
+      test_set_no_prop_swap)(test_multiset_no_prop_swap)(test_map_no_prop_swap)(
+      test_multimap_no_prop_swap))(
+                   (default_generator)(generate_collisions)(limited_range)))
 }
 RUN_TESTS()

test/unordered/unnecessary_copy_tests.cpp

@@ -13,8 +13,8 @@
 #include "../helpers/test.hpp"
 
 namespace unnecessary_copy_tests {
-struct count_copies
+  struct count_copies
-{
+  {
   private:
     BOOST_COPYABLE_AND_MOVABLE(count_copies)
   public:
@@ -90,22 +90,22 @@ struct count_copies
 
     int tag_;
     int id_;
-};
+  };
 
-bool operator==(count_copies const& x, count_copies const& y)
+  bool operator==(count_copies const& x, count_copies const& y)
-{
+  {
     return x.tag_ == y.tag_;
-}
+  }
 
-template <class T> T source() { return T(); }
+  template <class T> T source() { return T(); }
 
-void reset()
+  void reset()
-{
+  {
     count_copies::copies = 0;
     count_copies::moves = 0;
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\nReset\n" << std::endl;
-}
+  }
 }
 
 #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
@@ -114,10 +114,10 @@ namespace boost
 namespace unnecessary_copy_tests
 #endif
 {
-std::size_t hash_value(unnecessary_copy_tests::count_copies const& x)
+  std::size_t hash_value(unnecessary_copy_tests::count_copies const& x)
-{
+  {
     return static_cast<std::size_t>(x.tag_);
-}
+  }
 }
 
 // Boost.Move doesn't seem to work very well on this compiler.
@@ -139,15 +139,14 @@ std::size_t hash_value(unnecessary_copy_tests::count_copies const& x)
     BOOST_ERROR("Wrong number of copies.");                                    \
     BOOST_LIGHTWEIGHT_TEST_OSTREAM                                             \
       << "Number of copies: "                                                  \
-            << ::unnecessary_copy_tests::count_copies::copies                  \
+      << ::unnecessary_copy_tests::count_copies::copies << " expecting: " << n \
-            << " expecting: " << n << std::endl;                               \
+      << std::endl;                                                            \
   }
 #define MOVE_COUNT(n)                                                          \
   if (::unnecessary_copy_tests::count_copies::moves != n) {                    \
     BOOST_ERROR("Wrong number of moves.");                                     \
     BOOST_LIGHTWEIGHT_TEST_OSTREAM                                             \
-            << "Number of moves: "                                             \
+      << "Number of moves: " << ::unnecessary_copy_tests::count_copies::moves  \
-            << ::unnecessary_copy_tests::count_copies::moves                   \
       << " expecting: " << n << std::endl;                                     \
   }
 #define COPY_COUNT_RANGE(a, b)                                                 \
@@ -156,38 +155,37 @@ std::size_t hash_value(unnecessary_copy_tests::count_copies const& x)
     BOOST_ERROR("Wrong number of copies.");                                    \
     BOOST_LIGHTWEIGHT_TEST_OSTREAM                                             \
       << "Number of copies: "                                                  \
-            << ::unnecessary_copy_tests::count_copies::copies                  \
+      << ::unnecessary_copy_tests::count_copies::copies << " expecting: ["     \
-            << " expecting: [" << a << ", " << b << "]" << std::endl;          \
+      << a << ", " << b << "]" << std::endl;                                   \
   }
 #define MOVE_COUNT_RANGE(a, b)                                                 \
   if (::unnecessary_copy_tests::count_copies::moves < a ||                     \
       ::unnecessary_copy_tests::count_copies::moves > b) {                     \
     BOOST_ERROR("Wrong number of moves.");                                     \
     BOOST_LIGHTWEIGHT_TEST_OSTREAM                                             \
-            << "Number of moves: "                                             \
+      << "Number of moves: " << ::unnecessary_copy_tests::count_copies::moves  \
-            << ::unnecessary_copy_tests::count_copies::moves                   \
       << " expecting: [" << a << ", " << b << "]" << std::endl;                \
   }
 #define COPY_COUNT_EXTRA(a, b) COPY_COUNT_RANGE(a, a + b * EXTRA_CONSTRUCT_COST)
 #define MOVE_COUNT_EXTRA(a, b) MOVE_COUNT_RANGE(a, a + b * EXTRA_CONSTRUCT_COST)
 
 namespace unnecessary_copy_tests {
-int count_copies::copies;
+  int count_copies::copies;
-int count_copies::moves;
+  int count_copies::moves;
-int count_copies::id_count;
+  int count_copies::id_count;
 
-template <class T> void unnecessary_copy_insert_test(T*)
+  template <class T> void unnecessary_copy_insert_test(T*)
-{
+  {
     T x;
     BOOST_DEDUCED_TYPENAME T::value_type a;
     reset();
     x.insert(a);
     COPY_COUNT(1);
     MOVE_COUNT(0);
-}
+  }
 
-template <class T> void unnecessary_copy_insert_rvalue_set_test(T*)
+  template <class T> void unnecessary_copy_insert_rvalue_set_test(T*)
-{
+  {
     T x;
     BOOST_DEDUCED_TYPENAME T::value_type a;
     reset();
@@ -200,10 +198,10 @@ template <class T> void unnecessary_copy_insert_rvalue_set_test(T*)
     x.insert(boost::move(a));
     COPY_COUNT(0);
     MOVE_COUNT((x.size() == 2 ? 1 : 0));
-}
+  }
 
-template <class T> void unnecessary_copy_insert_rvalue_map_test(T*)
+  template <class T> void unnecessary_copy_insert_rvalue_map_test(T*)
-{
+  {
     // Doesn't currently try to emulate std::pair move construction,
     // so std::pair's require a copy. Could try emulating it in
     // construct_from_args.
@@ -230,29 +228,29 @@ template <class T> void unnecessary_copy_insert_rvalue_map_test(T*)
     COPY_COUNT(0);
     MOVE_COUNT((x.size() == 2 ? 1 : 0));
 #endif
-}
+  }
 
-boost::unordered_set<count_copies>* set;
+  boost::unordered_set<count_copies>* set;
-boost::unordered_multiset<count_copies>* multiset;
+  boost::unordered_multiset<count_copies>* multiset;
-boost::unordered_map<int, count_copies>* map;
+  boost::unordered_map<int, count_copies>* map;
-boost::unordered_multimap<int, count_copies>* multimap;
+  boost::unordered_multimap<int, count_copies>* multimap;
 
-UNORDERED_TEST(unnecessary_copy_insert_test, ((set)(multiset)(map)(multimap)))
+  UNORDERED_TEST(unnecessary_copy_insert_test, ((set)(multiset)(map)(multimap)))
-UNORDERED_TEST(unnecessary_copy_insert_rvalue_set_test, ((set)(multiset)))
+  UNORDERED_TEST(unnecessary_copy_insert_rvalue_set_test, ((set)(multiset)))
-UNORDERED_TEST(unnecessary_copy_insert_rvalue_map_test, ((map)(multimap)))
+  UNORDERED_TEST(unnecessary_copy_insert_rvalue_map_test, ((map)(multimap)))
 
-template <class T> void unnecessary_copy_emplace_test(T*)
+  template <class T> void unnecessary_copy_emplace_test(T*)
-{
+  {
     reset();
     T x;
     BOOST_DEDUCED_TYPENAME T::value_type a;
     COPY_COUNT(1);
     x.emplace(a);
     COPY_COUNT(2);
-}
+  }
 
-template <class T> void unnecessary_copy_emplace_rvalue_test(T*)
+  template <class T> void unnecessary_copy_emplace_rvalue_test(T*)
-{
+  {
     reset();
     T x;
     x.emplace(source<BOOST_DEDUCED_TYPENAME T::value_type>());
@@ -261,15 +259,16 @@ template <class T> void unnecessary_copy_emplace_rvalue_test(T*)
 #else
     COPY_COUNT(2);
 #endif
-}
+  }
 
-UNORDERED_TEST(unnecessary_copy_emplace_test, ((set)(multiset)(map)(multimap)))
+  UNORDERED_TEST(
-UNORDERED_TEST(
+    unnecessary_copy_emplace_test, ((set)(multiset)(map)(multimap)))
+  UNORDERED_TEST(
     unnecessary_copy_emplace_rvalue_test, ((set)(multiset)(map)(multimap)))
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-template <class T> void unnecessary_copy_emplace_std_move_test(T*)
+  template <class T> void unnecessary_copy_emplace_std_move_test(T*)
-{
+  {
     reset();
     T x;
     BOOST_DEDUCED_TYPENAME T::value_type a;
@@ -278,14 +277,14 @@ template <class T> void unnecessary_copy_emplace_std_move_test(T*)
     x.emplace(std::move(a));
     COPY_COUNT(1);
     MOVE_COUNT(1);
-}
+  }
 
-UNORDERED_TEST(
+  UNORDERED_TEST(
     unnecessary_copy_emplace_std_move_test, ((set)(multiset)(map)(multimap)))
 #endif
 
-template <class T> void unnecessary_copy_emplace_boost_move_test(T*)
+  template <class T> void unnecessary_copy_emplace_boost_move_test(T*)
-{
+  {
     reset();
     T x;
     BOOST_DEDUCED_TYPENAME T::value_type a;
@@ -300,13 +299,13 @@ template <class T> void unnecessary_copy_emplace_boost_move_test(T*)
     COPY_COUNT_RANGE(1, 2);
     MOVE_COUNT_RANGE(0, 1);
 #endif
-}
+  }
 
-UNORDERED_TEST(
+  UNORDERED_TEST(
     unnecessary_copy_emplace_boost_move_test, ((set)(multiset)(map)(multimap)))
 
-template <class T> void unnecessary_copy_emplace_boost_move_set_test(T*)
+  template <class T> void unnecessary_copy_emplace_boost_move_set_test(T*)
-{
+  {
     reset();
     T x;
     BOOST_DEDUCED_TYPENAME T::value_type a;
@@ -315,12 +314,13 @@ template <class T> void unnecessary_copy_emplace_boost_move_set_test(T*)
     x.emplace(boost::move(a));
     COPY_COUNT(1);
     MOVE_COUNT(1);
-}
+  }
 
-UNORDERED_TEST(unnecessary_copy_emplace_boost_move_set_test, ((set)(multiset)))
+  UNORDERED_TEST(
+    unnecessary_copy_emplace_boost_move_set_test, ((set)(multiset)))
 
-template <class T> void unnecessary_copy_emplace_boost_move_map_test(T*)
+  template <class T> void unnecessary_copy_emplace_boost_move_map_test(T*)
-{
+  {
     reset();
     T x;
     COPY_COUNT(0);
@@ -336,12 +336,13 @@ template <class T> void unnecessary_copy_emplace_boost_move_map_test(T*)
     COPY_COUNT(1);
     MOVE_COUNT(1);
 #endif
-}
+  }
 
-UNORDERED_TEST(unnecessary_copy_emplace_boost_move_map_test, ((map)(multimap)))
+  UNORDERED_TEST(
+    unnecessary_copy_emplace_boost_move_map_test, ((map)(multimap)))
 
-UNORDERED_AUTO_TEST(unnecessary_copy_emplace_set_test)
+  UNORDERED_AUTO_TEST(unnecessary_copy_emplace_set_test)
-{
+  {
     // When calling 'source' the object is moved on some compilers, but not
     // others. So count that here to adjust later.
 
@@ -422,10 +423,10 @@ UNORDERED_AUTO_TEST(unnecessary_copy_emplace_set_test)
     x.emplace(b, b);
     COPY_COUNT(1);
     MOVE_COUNT(0);
-}
+  }
 
-UNORDERED_AUTO_TEST(unnecessary_copy_emplace_map_test)
+  UNORDERED_AUTO_TEST(unnecessary_copy_emplace_map_test)
-{
+  {
     // When calling 'source' the object is moved on some compilers, but not
     // others. So count that here to adjust later.
 
@@ -547,8 +548,7 @@ UNORDERED_AUTO_TEST(unnecessary_copy_emplace_map_test)
 
     reset();
     x.emplace(boost::unordered::piecewise_construct,
-        std::make_tuple(std::ref(b.first)),
+      std::make_tuple(std::ref(b.first)), std::make_tuple(std::ref(b.second)));
-        std::make_tuple(std::ref(b.second)));
     COPY_COUNT(0);
     MOVE_COUNT(0);
 
@@ -578,7 +578,7 @@ UNORDERED_AUTO_TEST(unnecessary_copy_emplace_map_test)
 #endif
 
 #endif
-}
+  }
 }
 
 RUN_TESTS()