diff --git a/include/boost/unordered/detail/buckets.hpp b/include/boost/unordered/detail/buckets.hpp
index 0f513e44..c4b8a898 100644
--- a/include/boost/unordered/detail/buckets.hpp
+++ b/include/boost/unordered/detail/buckets.hpp
@@ -10,12 +10,19 @@
 #include <boost/config.hpp>
 #include <boost/assert.hpp>
 #include <boost/unordered/detail/node.hpp>
+#include <boost/unordered/detail/util.hpp>
 
 namespace boost { namespace unordered_detail {
     
     ////////////////////////////////////////////////////////////////////////////
     // Buckets
     
+    template <class A, class G>
+    inline std::size_t hash_buckets<A, G>::max_bucket_count() const {
+        // -1 to account for the sentinel.
+        return prev_prime(this->bucket_alloc().max_size() - 1);
+    }
+
     template <class A, class G>
     inline BOOST_DEDUCED_TYPENAME hash_buckets<A, G>::bucket_ptr
         hash_buckets<A, G>::get_bucket(std::size_t num) const
diff --git a/include/boost/unordered/detail/equivalent.hpp b/include/boost/unordered/detail/equivalent.hpp
index 7e52a609..970c18bc 100644
--- a/include/boost/unordered/detail/equivalent.hpp
+++ b/include/boost/unordered/detail/equivalent.hpp
@@ -28,7 +28,7 @@ namespace boost { namespace unordered_detail {
             node_ptr it1 = i->next_;
             while(BOOST_UNORDERED_BORLAND_BOOL(it1))
             {
-                node_ptr it2 = other.find_iterator(get_key_from_ptr(it1));
+                node_ptr it2 = other.find_iterator(this->get_key_from_ptr(it1));
                 if(!BOOST_UNORDERED_BORLAND_BOOL(it2)) return false;
                 
                 node_ptr end1 = node::next_group(it1);
@@ -77,7 +77,7 @@ namespace boost { namespace unordered_detail {
         hash_equivalent_table<H, P, A, K>::iterator_base
         hash_equivalent_table<H, P, A, K>::emplace_impl(node_constructor& a)
     {
-        key_type const& k = get_key(a.value());
+        key_type const& k = this->get_key(a.value());
         std::size_t hash_value = this->hash_function()(k);
         
         if(!this->size_) {
@@ -85,7 +85,7 @@ namespace boost { namespace unordered_detail {
         }
         else {
             bucket_ptr bucket = this->bucket_ptr_from_hash(hash_value);
-            node_ptr position = find_iterator(bucket, k);
+            node_ptr position = this->find_iterator(bucket, k);
 
             // reserve has basic exception safety if the hash function
             // throws, strong otherwise.
@@ -100,9 +100,9 @@ namespace boost { namespace unordered_detail {
     inline void hash_equivalent_table<H, P, A, K>
             ::emplace_impl_no_rehash(node_constructor& a)
     {
-        key_type const& k = get_key(a.value());
+        key_type const& k = this->get_key(a.value());
         bucket_ptr bucket = this->get_bucket(this->bucket_index(k));
-        add_node(a, bucket, find_iterator(bucket, k));
+        add_node(a, bucket, this->find_iterator(bucket, k));
     }
 
 #if defined(BOOST_UNORDERED_STD_FORWARD)
diff --git a/include/boost/unordered/detail/fwd.hpp b/include/boost/unordered/detail/fwd.hpp
index 3a5e3f73..5696cbca 100644
--- a/include/boost/unordered/detail/fwd.hpp
+++ b/include/boost/unordered/detail/fwd.hpp
@@ -298,10 +298,7 @@ namespace boost { namespace unordered_detail {
             return allocators_.first(); }
         node_allocator& node_alloc() {
             return allocators_.second(); }
-        std::size_t max_bucket_count() const {
-            // -1 to account for the sentinel.
-            return prev_prime(this->bucket_alloc().max_size() - 1);
-        }
+        std::size_t max_bucket_count() const;
 
         // Constructors
 
@@ -443,7 +440,6 @@ namespace boost { namespace unordered_detail {
         typedef H hasher;
         typedef P key_equal;
         typedef A value_allocator;
-        typedef G grouped;
         typedef K key_extractor;
         typedef hash_buffered_functions<H, P> base;
         typedef hash_buckets<A, G> buckets;
@@ -575,7 +571,7 @@ namespace boost { namespace unordered_detail {
 
     template <class H, class P, class A, class K>
     class hash_unique_table :
-        public hash_table<H, P, A, boost::unordered_detail::ungrouped, K>
+        public hash_table<H, P, A, ungrouped, K>
         
     {
     public:
@@ -669,7 +665,7 @@ namespace boost { namespace unordered_detail {
 
     template <class H, class P, class A, class K>
     class hash_equivalent_table :
-        public hash_table<H, P, A, boost::unordered_detail::grouped, K>
+        public hash_table<H, P, A, grouped, K>
         
     {
     public:
@@ -678,9 +674,8 @@ namespace boost { namespace unordered_detail {
         typedef A value_allocator;
         typedef K key_extractor;
 
-        typedef hash_table<H, P, A, boost::unordered_detail::grouped, K> table;
-        typedef hash_node_constructor<A, boost::unordered_detail::grouped>
-            node_constructor;
+        typedef hash_table<H, P, A, grouped, K> table;
+        typedef hash_node_constructor<A, grouped> node_constructor;
         typedef hash_iterator_base<A, grouped> iterator_base;
 
         typedef BOOST_DEDUCED_TYPENAME table::key_type key_type;
diff --git a/include/boost/unordered/detail/table.hpp b/include/boost/unordered/detail/table.hpp
index bba3a07f..66c9d744 100644
--- a/include/boost/unordered/detail/table.hpp
+++ b/include/boost/unordered/detail/table.hpp
@@ -14,7 +14,6 @@
 #include <boost/iterator/iterator_categories.hpp>
 
 #include <boost/unordered/detail/buckets.hpp>
-#include <boost/unordered/detail/util.hpp>
 
 namespace boost { namespace unordered_detail {
 
diff --git a/include/boost/unordered/detail/unique.hpp b/include/boost/unordered/detail/unique.hpp
index 552a1d51..b696e1a0 100644
--- a/include/boost/unordered/detail/unique.hpp
+++ b/include/boost/unordered/detail/unique.hpp
@@ -28,7 +28,7 @@ namespace boost { namespace unordered_detail {
             node_ptr it1 = i->next_;
             while(BOOST_UNORDERED_BORLAND_BOOL(it1))
             {
-                node_ptr it2 = other.find_iterator(get_key_from_ptr(it1));
+                node_ptr it2 = other.find_iterator(this->get_key_from_ptr(it1));
                 if(!BOOST_UNORDERED_BORLAND_BOOL(it2)) return false;
                 if(!extractor::compare_mapped(
                     node::get_value(it1), node::get_value(it2)))
@@ -76,7 +76,7 @@ namespace boost { namespace unordered_detail {
             return *this->emplace_empty_impl_with_node(a, 1);
         }
 
-        node_ptr pos = find_iterator(bucket, k);
+        node_ptr pos = this->find_iterator(bucket, k);
 
         if (BOOST_UNORDERED_BORLAND_BOOL(pos)) {
             return node::get_value(pos);
@@ -102,14 +102,13 @@ namespace boost { namespace unordered_detail {
 
     template <class H, class P, class A, class K>
     inline BOOST_DEDUCED_TYPENAME hash_unique_table<H, P, A, K>::emplace_return
-    hash_unique_table<H, P, A, K>
-        ::emplace_impl_with_node(node_constructor& a)
+    hash_unique_table<H, P, A, K>::emplace_impl_with_node(node_constructor& a)
     {
         // No side effects in this initial code
-        key_type const& k = get_key(a.value());
+        key_type const& k = this->get_key(a.value());
         std::size_t hash_value = this->hash_function()(k);
         bucket_ptr bucket = this->bucket_ptr_from_hash(hash_value);
-        node_ptr pos = find_iterator(bucket, k);
+        node_ptr pos = this->find_iterator(bucket, k);
         
         if (BOOST_UNORDERED_BORLAND_BOOL(pos)) {
             // Found an existing key, return it (no throw).
@@ -139,7 +138,7 @@ namespace boost { namespace unordered_detail {
         // No side effects in this initial code
         std::size_t hash_value = this->hash_function()(k);
         bucket_ptr bucket = this->bucket_ptr_from_hash(hash_value);
-        node_ptr pos = find_iterator(bucket, k);
+        node_ptr pos = this->find_iterator(bucket, k);
 
         if (BOOST_UNORDERED_BORLAND_BOOL(pos)) {
             // Found an existing key, return it (no throw).
@@ -203,7 +202,7 @@ namespace boost { namespace unordered_detail {
         std::size_t hash_value = this->hash_function()(k);                     \
         bucket_ptr bucket                                                      \
             = this->bucket_ptr_from_hash(hash_value);                          \
-        node_ptr pos = find_iterator(bucket, k);                               \
+        node_ptr pos = this->find_iterator(bucket, k);                         \
                                                                                \
         if (BOOST_UNORDERED_BORLAND_BOOL(pos)) {                               \
             return emplace_return(iterator_base(bucket, pos), false);          \
@@ -330,7 +329,7 @@ namespace boost { namespace unordered_detail {
             key_type const& k = extractor::extract(*i);
             std::size_t hash_value = this->hash_function()(k);
             bucket_ptr bucket = this->bucket_ptr_from_hash(hash_value);
-            node_ptr pos = find_iterator(bucket, k);
+            node_ptr pos = this->find_iterator(bucket, k);
 
             if (!BOOST_UNORDERED_BORLAND_BOOL(pos)) {
                 // Doesn't already exist, add to bucket.
diff --git a/test/exception/Jamfile.v2 b/test/exception/Jamfile.v2
index 92e25055..a8508588 100644
--- a/test/exception/Jamfile.v2
+++ b/test/exception/Jamfile.v2
@@ -8,11 +8,7 @@ import testing ;
 #alias framework : /boost/test//boost_unit_test_framework ;
 alias framework : ;
 
-project unordered-test/exception-tests
-    : requirements
-        <toolset>intel-linux:"<cxxflags>-strict_ansi -cxxlib-icc"
-        <toolset>gcc:<cxxflags>"-Wsign-promo -Wunused-parameter"
-    ;
+project unordered-test/exception-tests ;
 
 test-suite unordered-exception
     :
diff --git a/test/unordered/Jamfile.v2 b/test/unordered/Jamfile.v2
index ee1505f7..882ec132 100644
--- a/test/unordered/Jamfile.v2
+++ b/test/unordered/Jamfile.v2
@@ -7,10 +7,11 @@ import testing ;
 
 project unordered-test/unordered
     : requirements
-        <toolset>intel-linux:"<cxxflags>-strict_ansi -cxxlib-icc"
-        <toolset>gcc:<cxxflags>"-Wsign-promo -Wunused-parameter"
-        #<toolset>msvc:<cxxflags>/W4
         <warnings>all
+        <toolset>intel:<warnings>on
+        <toolset>intel:<cxxflags>-strict-ansi
+        <toolset>msvc:<cxxflags>/W4
+        <toolset>gcc:<cxxflags>"-Wsign-promo -Wunused-parameter -pedantic"
     ;
 
 test-suite unordered
diff --git a/test/unordered/insert_tests.cpp b/test/unordered/insert_tests.cpp
index a277cbb7..b116acc0 100644
--- a/test/unordered/insert_tests.cpp
+++ b/test/unordered/insert_tests.cpp
@@ -407,7 +407,7 @@ UNORDERED_AUTO_TEST(insert_initializer_list_set)
 UNORDERED_AUTO_TEST(insert_initializer_list_multiset)
 {
     boost::unordered_multiset<std::string> multiset;
-    multiset.insert({});
+    //multiset.insert({});
     BOOST_TEST(multiset.empty());
     multiset.insert({"a"});
     BOOST_TEST_EQ(multiset.size(), 1u);
@@ -423,7 +423,7 @@ UNORDERED_AUTO_TEST(insert_initializer_list_multiset)
 UNORDERED_AUTO_TEST(insert_initializer_list_map)
 {
     boost::unordered_map<std::string, std::string> map;
-    map.insert({});
+    //map.insert({});
     BOOST_TEST(map.empty());
     map.insert({{"a", "b"},{"a", "b"},{"d", ""}});
     BOOST_TEST_EQ(map.size(), 2u);
@@ -432,7 +432,7 @@ UNORDERED_AUTO_TEST(insert_initializer_list_map)
 UNORDERED_AUTO_TEST(insert_initializer_list_multimap)
 {
     boost::unordered_multimap<std::string, std::string> multimap;
-    multimap.insert({});
+    //multimap.insert({});
     BOOST_TEST(multimap.empty());
     multimap.insert({{"a", "b"},{"a", "b"},{"d", ""}});
     BOOST_TEST_EQ(multimap.size(), 3u);