diff --git a/include/boost/range/concepts.hpp b/include/boost/range/concepts.hpp
index b70c586..cc039aa 100644
--- a/include/boost/range/concepts.hpp
+++ b/include/boost/range/concepts.hpp
@@ -74,10 +74,10 @@ namespace boost {
         // Ultimately modeling the range concepts using composition
         // with the Boost.Iterator concepts would render the library
         // incompatible with many common Boost.Lambda expressions.
-        template<typename Iterator>
+        template<class Iterator>
         struct IncrementableIteratorConcept : CopyConstructible<Iterator>
         {
-            typedef typename iterator_traversal<Iterator>::type traversal_category;
+            typedef BOOST_DEDUCED_TYPENAME iterator_traversal<Iterator>::type traversal_category;
 
             BOOST_CONCEPT_ASSERT((
                 Convertible<
@@ -94,42 +94,42 @@ namespace boost {
             Iterator i;
         };
 
-        template<typename Iterator>
+        template<class Iterator>
         struct SinglePassIteratorConcept
             : IncrementableIteratorConcept<Iterator>
             , EqualityComparable<Iterator>
         {
             BOOST_CONCEPT_ASSERT((
                 Convertible<
-                    typename SinglePassIteratorConcept::traversal_category,
+                    BOOST_DEDUCED_TYPENAME SinglePassIteratorConcept::traversal_category,
                     single_pass_traversal_tag
                 >));
         };
 
-        template<typename Iterator>
+        template<class Iterator>
         struct ForwardIteratorConcept
             : SinglePassIteratorConcept<Iterator>
             , DefaultConstructible<Iterator>
         {
-            typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
+            typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::difference_type difference_type;
 
             BOOST_MPL_ASSERT((is_integral<difference_type>));
             BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
 
             BOOST_CONCEPT_ASSERT((
                 Convertible<
-                    typename ForwardIteratorConcept::traversal_category,
+                    BOOST_DEDUCED_TYPENAME ForwardIteratorConcept::traversal_category,
                     forward_traversal_tag
                 >));
          };
 
-         template<typename Iterator>
+         template<class Iterator>
          struct BidirectionalIteratorConcept
              : ForwardIteratorConcept<Iterator>
          {
              BOOST_CONCEPT_ASSERT((
                  Convertible<
-                     typename BidirectionalIteratorConcept::traversal_category,
+                     BOOST_DEDUCED_TYPENAME BidirectionalIteratorConcept::traversal_category,
                      bidirectional_traversal_tag
                  >));
 
@@ -142,13 +142,13 @@ namespace boost {
              Iterator i;
          };
 
-         template<typename Iterator>
+         template<class Iterator>
          struct RandomAccessIteratorConcept
              : BidirectionalIteratorConcept<Iterator>
          {
              BOOST_CONCEPT_ASSERT((
                  Convertible<
-                     typename RandomAccessIteratorConcept::traversal_category,
+                     BOOST_DEDUCED_TYPENAME RandomAccessIteratorConcept::traversal_category,
                      random_access_traversal_tag
                  >));
 
@@ -162,7 +162,7 @@ namespace boost {
                  n = i - j;
              }
          private:
-             typename RandomAccessIteratorConcept::difference_type n;
+             BOOST_DEDUCED_TYPENAME RandomAccessIteratorConcept::difference_type n;
              Iterator i;
              Iterator j;
          };
@@ -170,11 +170,11 @@ namespace boost {
     } // namespace range_detail
 
     //! Check if a type T models the SinglePassRange range concept.
-    template<typename T>
+    template<class T>
     struct SinglePassRangeConcept
     {
-         typedef typename range_iterator<T const>::type  const_iterator;
-         typedef typename range_iterator<T>::type        iterator;
+         typedef BOOST_DEDUCED_TYPENAME range_iterator<T const>::type  const_iterator;
+         typedef BOOST_DEDUCED_TYPENAME range_iterator<T>::type        iterator;
 
          BOOST_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<iterator>));
          BOOST_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<const_iterator>));
@@ -211,17 +211,17 @@ namespace boost {
     };
 
     //! Check if a type T models the ForwardRange range concept.
-    template<typename T>
+    template<class T>
     struct ForwardRangeConcept : SinglePassRangeConcept<T>
     {
-        BOOST_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<typename ForwardRangeConcept::iterator>));
-        BOOST_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<typename ForwardRangeConcept::const_iterator>));
+        BOOST_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<BOOST_DEDUCED_TYPENAME ForwardRangeConcept::iterator>));
+        BOOST_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<BOOST_DEDUCED_TYPENAME ForwardRangeConcept::const_iterator>));
     };
 
-    template<typename Range>
+    template<class Range>
     struct WriteableRangeConcept
     {
-        typedef typename range_iterator<Range>::type iterator;
+        typedef BOOST_DEDUCED_TYPENAME range_iterator<Range>::type iterator;
 
         BOOST_CONCEPT_USAGE(WriteableRangeConcept)
         {
@@ -229,11 +229,11 @@ namespace boost {
         }
     private:
         iterator i;
-        typename range_value<Range>::type v;
+        BOOST_DEDUCED_TYPENAME range_value<Range>::type v;
     };
 
     //! Check if a type T models the WriteableForwardRange range concept.
-    template<typename T>
+    template<class T>
     struct WriteableForwardRangeConcept
         : ForwardRangeConcept<T>
         , WriteableRangeConcept<T>
@@ -241,15 +241,15 @@ namespace boost {
     };
 
     //! Check if a type T models the BidirectionalRange range concept.
-    template<typename T>
+    template<class T>
     struct BidirectionalRangeConcept : ForwardRangeConcept<T>
     {
-        BOOST_CONCEPT_ASSERT((BidirectionalIteratorConcept<typename BidirectionalRangeConcept::iterator>));
-	BOOST_CONCEPT_ASSERT((BidirectionalIteratorConcept<typename BidirectionalRangeConcept::const_iterator>));
+        BOOST_CONCEPT_ASSERT((BidirectionalIteratorConcept<BOOST_DEDUCED_TYPENAME BidirectionalRangeConcept::iterator>));
+        BOOST_CONCEPT_ASSERT((BidirectionalIteratorConcept<BOOST_DEDUCED_TYPENAME BidirectionalRangeConcept::const_iterator>));
     };
 
     //! Check if a type T models the WriteableBidirectionalRange range concept.
-    template<typename T>
+    template<class T>
     struct WriteableBidirectionalRangeConcept
         : BidirectionalRangeConcept<T>
         , WriteableRangeConcept<T>
@@ -257,15 +257,15 @@ namespace boost {
     };
 
     //! Check if a type T models the RandomAccessRange range concept.
-    template<typename T>
+    template<class T>
     struct RandomAccessRangeConcept : BidirectionalRangeConcept<T>
     {
-        BOOST_CONCEPT_ASSERT((RandomAccessIteratorConcept<typename RandomAccessRangeConcept::iterator>));
-        BOOST_CONCEPT_ASSERT((RandomAccessIteratorConcept<typename RandomAccessRangeConcept::const_iterator>));
+        BOOST_CONCEPT_ASSERT((RandomAccessIteratorConcept<BOOST_DEDUCED_TYPENAME RandomAccessRangeConcept::iterator>));
+        BOOST_CONCEPT_ASSERT((RandomAccessIteratorConcept<BOOST_DEDUCED_TYPENAME RandomAccessRangeConcept::const_iterator>));
     };
 
     //! Check if a type T models the WriteableRandomAccessRange range concept.
-    template<typename T>
+    template<class T>
     struct WriteableRandomAccessRangeConcept
         : RandomAccessRangeConcept<T>
         , WriteableRangeConcept<T>
diff --git a/test/iterator_pair.cpp b/test/iterator_pair.cpp
old mode 100755
new mode 100644
index 2546817..495bd6f
--- a/test/iterator_pair.cpp
+++ b/test/iterator_pair.cpp
@@ -23,8 +23,6 @@
 #include <boost/test/test_tools.hpp>
 #include <vector>
 
-using namespace boost;
-
 void check_iterator_pair()
 {
     typedef std::vector<int> vec_t;
@@ -35,57 +33,56 @@ void check_iterator_pair()
     typedef std::pair<vec_t::const_iterator,vec_t::const_iterator>
                              const_pair_t;
     typedef const pair_t     const_pair_tt;
-    pair_t                   pair       = std::make_pair( begin( vec ), end( vec ) );
-    const_pair_t             const_pair = std::make_pair( begin( vec ), end( vec ) );
+    pair_t                   pair       = std::make_pair( boost::begin( vec ), boost::end( vec ) );
+    const_pair_t             const_pair = std::make_pair( boost::begin( vec ), boost::end( vec ) );
     const_pair_tt            constness_pair( pair );
-    
 
-    BOOST_STATIC_ASSERT(( is_same< range_value<pair_t>::type, 
-                          detail::iterator_traits<pair_t::first_type>::value_type>::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_iterator<pair_t>::type, pair_t::first_type >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_const_iterator<pair_t>::type, pair_t::first_type >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_difference<pair_t>::type,                           
-                          detail::iterator_traits<pair_t::first_type>::difference_type >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_size<pair_t>::type, std::size_t >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_iterator<pair_t>::type, pair_t::first_type >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_iterator<const_pair_t>::type, const_pair_t::first_type >::value ));
-    
-    BOOST_STATIC_ASSERT(( is_same< range_value<const_pair_tt>::type, 
-                          detail::iterator_traits<const_pair_t::first_type>::value_type>::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
+
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_value<pair_t>::type,
+                          boost::detail::iterator_traits<pair_t::first_type>::value_type>::value ));
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<pair_t>::type, pair_t::first_type >::value ));
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_const_iterator<pair_t>::type, pair_t::first_type >::value ));
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_difference<pair_t>::type,
+                          boost::detail::iterator_traits<pair_t::first_type>::difference_type >::value ));
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_size<pair_t>::type, std::size_t >::value ));
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<pair_t>::type, pair_t::first_type >::value ));
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<const_pair_t>::type, const_pair_t::first_type >::value ));
+
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_value<const_pair_tt>::type,
+                          boost::detail::iterator_traits<const_pair_t::first_type>::value_type>::value ));
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
     //
     // This behavior is not supported with v2.
     //BOOST_STATIC_ASSERT(( is_same< range_const_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_difference<const_pair_tt>::type,                           
-                          detail::iterator_traits<const_pair_tt::first_type>::difference_type >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_size<const_pair_tt>::type, std::size_t >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_difference<const_pair_tt>::type,
+                          boost::detail::iterator_traits<const_pair_tt::first_type>::difference_type >::value ));
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_size<const_pair_tt>::type, std::size_t >::value ));
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
 
-    BOOST_CHECK( begin( pair ) == pair.first );
-    BOOST_CHECK( end( pair )   == pair.second );
-    BOOST_CHECK( empty( pair ) == (pair.first == pair.second) );
-    BOOST_CHECK( size( pair )  == std::distance( pair.first, pair.second ) );
-    
-    BOOST_CHECK( begin( const_pair ) == const_pair.first );
-    BOOST_CHECK( end( const_pair )   == const_pair.second );
-    BOOST_CHECK( empty( const_pair ) == (const_pair.first == const_pair.second) );
-    BOOST_CHECK( size( const_pair )  == std::distance( const_pair.first, const_pair.second ) );
+    BOOST_CHECK( boost::begin( pair ) == pair.first );
+    BOOST_CHECK( boost::end( pair )   == pair.second );
+    BOOST_CHECK( boost::empty( pair ) == (pair.first == pair.second) );
+    BOOST_CHECK( boost::size( pair )  == std::distance( pair.first, pair.second ) );
 
-    BOOST_CHECK( begin( constness_pair ) == constness_pair.first );
-    BOOST_CHECK( end( constness_pair )   == constness_pair.second );
-    BOOST_CHECK( empty( constness_pair ) == (constness_pair.first == const_pair.second) );
-    BOOST_CHECK( size( constness_pair )  == std::distance( constness_pair.first, constness_pair.second ) );
+    BOOST_CHECK( boost::begin( const_pair ) == const_pair.first );
+    BOOST_CHECK( boost::end( const_pair )   == const_pair.second );
+    BOOST_CHECK( boost::empty( const_pair ) == (const_pair.first == const_pair.second) );
+    BOOST_CHECK( boost::size( const_pair )  == std::distance( const_pair.first, const_pair.second ) );
+
+    BOOST_CHECK( boost::begin( constness_pair ) == constness_pair.first );
+    BOOST_CHECK( boost::end( constness_pair )   == constness_pair.second );
+    BOOST_CHECK( boost::empty( constness_pair ) == (constness_pair.first == const_pair.second) );
+    BOOST_CHECK( boost::size( constness_pair )  == std::distance( constness_pair.first, constness_pair.second ) );
 
 }
 
 
 #include <boost/test/unit_test.hpp>
-using boost::unit_test::test_suite;
 
-test_suite* init_unit_test_suite( int argc, char* argv[] )
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
 {
-    test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
+    boost::unit_test::test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
 
     test->add( BOOST_TEST_CASE( &check_iterator_pair ) );
 
diff --git a/test/iterator_range.cpp b/test/iterator_range.cpp
old mode 100755
new mode 100644
index db531d3..47bc565
--- a/test/iterator_range.cpp
+++ b/test/iterator_range.cpp
@@ -19,32 +19,29 @@
 
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/functions.hpp>
-#include <boost/range/as_literal.hpp> 
+#include <boost/range/as_literal.hpp>
 #include <boost/test/test_tools.hpp>
 #include <boost/test/unit_test.hpp>
 #include <iostream>
 #include <string>
 
-using namespace boost;
-using namespace std;
-
 void check_reference_type();
 
 void check_iterator_range()
 {
-   
-    typedef string::iterator               iterator;
-    typedef string::const_iterator         const_iterator;
-    typedef iterator_range<iterator>       irange;
-    typedef iterator_range<const_iterator> cirange;
-    string       str  = "hello world";
-    const string cstr = "const world";
-    irange r    = make_iterator_range( str );
-    r           = make_iterator_range( str.begin(), str.end() );
-    cirange r2  = make_iterator_range( cstr );
-    r2          = make_iterator_range( cstr.begin(), cstr.end() );
-    r2          = make_iterator_range( str );
- 
+
+    typedef std::string::iterator                 iterator;
+    typedef std::string::const_iterator           const_iterator;
+    typedef boost::iterator_range<iterator>       irange;
+    typedef boost::iterator_range<const_iterator> cirange;
+    std::string       str  = "hello world";
+    const std::string cstr = "const world";
+    irange r    = boost::make_iterator_range( str );
+    r           = boost::make_iterator_range( str.begin(), str.end() );
+    cirange r2  = boost::make_iterator_range( cstr );
+    r2          = boost::make_iterator_range( cstr.begin(), cstr.end() );
+    r2          = boost::make_iterator_range( str );
+
     BOOST_CHECK( !r.empty() );
     BOOST_CHECK( !r2.empty() );
 
@@ -53,7 +50,7 @@ void check_iterator_range()
 //        BOOST_CHECK( false );
 //    if( !(bool)r2 )
 //        BOOST_CHECK( false );
-//#else    
+//#else
     if( !r )
         BOOST_CHECK( false );
     if( !r2 )
@@ -62,55 +59,53 @@ void check_iterator_range()
 
     BOOST_CHECK_EQUAL( r.size(), size( r ) );
     BOOST_CHECK_EQUAL( r2.size(), size( r2 ) );
-    
-    BOOST_CHECK_EQUAL( distance( r.begin(), r.end() ), 
-                       distance( begin( r2 ), end( r2 ) ) );
-    cout << r << r2;
 
-        
+    BOOST_CHECK_EQUAL( std::distance( r.begin(), r.end() ),
+                       std::distance( begin( r2 ), end( r2 ) ) );
+    std::cout << r << r2;
+
+
 #ifndef BOOST_NO_STD_WSTRING
-    wcout << make_iterator_range( wstring( L"a wide string" ) ) 
-          << make_iterator_range( L"another wide string" );
-#endif    
-    
-    string res  = copy_range<string>( r );
-    BOOST_CHECK( equal( res.begin(), res.end(), r.begin() ) );
+    std::wcout << boost::make_iterator_range( std::wstring( L"a wide string" ) )
+               << boost::make_iterator_range( L"another wide string" );
+#endif
 
-    irange rr = make_iterator_range( str );
+    std::string res  = boost::copy_range<std::string>( r );
+    BOOST_CHECK_EQUAL_COLLECTIONS( res.begin(), res.end(), r.begin(), r.end() );
+
+    irange rr = boost::make_iterator_range( str );
     BOOST_CHECK( rr.equal( r ) );
 
-    rr  = make_iterator_range( str.begin(), str.begin() + 5 );
-    BOOST_CHECK( rr == as_literal("hello") );
-    BOOST_CHECK( rr != as_literal("hell") );
-    BOOST_CHECK( rr < as_literal("hello dude") );
-    BOOST_CHECK( as_literal("hello") == rr );
-    BOOST_CHECK( as_literal("hell")  != rr );
-    BOOST_CHECK( ! (as_literal("hello dude") < rr ) );
+    rr  = boost::make_iterator_range( str.begin(), str.begin() + 5 );
+    BOOST_CHECK( rr == boost::as_literal("hello") );
+    BOOST_CHECK( rr != boost::as_literal("hell") );
+    BOOST_CHECK( rr < boost::as_literal("hello dude") );
+    BOOST_CHECK( boost::as_literal("hello") == rr );
+    BOOST_CHECK( boost::as_literal("hell")  != rr );
+    BOOST_CHECK( ! (boost::as_literal("hello dude") < rr ) );
     irange rrr = rr;
     BOOST_CHECK( rrr == rr );
     BOOST_CHECK( !( rrr != rr ) );
     BOOST_CHECK( !( rrr < rr ) );
 
-    const irange cr = make_iterator_range( str );
+    const irange cr = boost::make_iterator_range( str );
     BOOST_CHECK_EQUAL( cr.front(), 'h' );
     BOOST_CHECK_EQUAL( cr.back(), 'd' );
     BOOST_CHECK_EQUAL( cr[1], 'e' );
     BOOST_CHECK_EQUAL( cr(1), 'e' );
 
-    rrr = make_iterator_range( str, 1, -1 );
-    BOOST_CHECK( rrr == as_literal("ello worl") );
-    rrr = make_iterator_range( rrr, -1, 1 );
+    rrr = boost::make_iterator_range( str, 1, -1 );
+    BOOST_CHECK( rrr == boost::as_literal("ello worl") );
+    rrr = boost::make_iterator_range( rrr, -1, 1 );
     BOOST_CHECK( rrr == str );
 
     check_reference_type();
 }
 
 
-using boost::unit_test::test_suite;
-
-test_suite* init_unit_test_suite( int argc, char* argv[] )
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
 {
-    test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
+    boost::unit_test::test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
 
     test->add( BOOST_TEST_CASE( &check_iterator_range ) );
 
@@ -122,16 +117,16 @@ test_suite* init_unit_test_suite( int argc, char* argv[] )
 //
 // Check that constness is propgated correct from
 // the iterator types.
-// 
+//
 // Test contributed by Larry Evans.
-// 
+//
 
 template< class Container >
 int test_iter_range( Container& a_cont )
 {
-    typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type citer_type;
-    typedef iterator_range<citer_type> riter_type;
-    riter_type a_riter( make_iterator_range( a_cont ) );
+    typedef BOOST_DEDUCED_TYPENAME boost::range_iterator<Container>::type citer_type;
+    typedef boost::iterator_range<citer_type> riter_type;
+    riter_type a_riter( boost::make_iterator_range( a_cont ) );
     a_riter.front();
     a_riter.back();
     int i = a_riter[0];
@@ -142,7 +137,7 @@ int test_iter_range( Container& a_cont )
 
 void check_reference_type()
 {
-    typedef vector<int> veci_type;
+    typedef std::vector<int> veci_type;
     veci_type a_vec;
     a_vec.push_back( 999 );
     test_iter_range<veci_type>(a_vec);
diff --git a/test/reversible_range.cpp b/test/reversible_range.cpp
old mode 100755
new mode 100644
index 9dfe8d0..98cc423
--- a/test/reversible_range.cpp
+++ b/test/reversible_range.cpp
@@ -27,44 +27,39 @@
 #include <vector>
 #include <algorithm>
 
-using namespace boost;
-using namespace std;
-
 void check_iterator()
 {
-    typedef vector<int>                           vec_t;
-    typedef vec_t::iterator                       iterator;
-    typedef pair<iterator,iterator>               pair_t;
-    typedef range_reverse_iterator<pair_t>::type  rev_iterator;
-    typedef pair<rev_iterator,rev_iterator>       rev_pair_t;
-    
+    typedef std::vector<int>                            vec_t;
+    typedef vec_t::iterator                             iterator;
+    typedef std::pair<iterator,iterator>                pair_t;
+    typedef boost::range_reverse_iterator<pair_t>::type rev_iterator;
+    typedef std::pair<rev_iterator,rev_iterator>        rev_pair_t;
+
     vec_t                            vec;
-    pair_t                           p    = make_pair( vec.begin(), vec.end() );
-    rev_pair_t                       rp   = make_pair( rbegin( p ), rend( p ) );
+    pair_t                           p    = std::make_pair( vec.begin(), vec.end() );
+    rev_pair_t                       rp   = std::make_pair( boost::rbegin( p ), boost::rend( p ) );
     int                             a[]  = {1,2,3,4,5,6,7,8,9,10};
-    const int                       ca[] = {1,2,3,4,5,6,7,8,9,10,11,12};                        
-    BOOST_CHECK( rbegin( vec ) == range_reverse_iterator<vec_t>::type( vec.end() ) );
-    BOOST_CHECK( rend( vec ) == range_reverse_iterator<vec_t>::type( vec.begin() ) );
-    BOOST_CHECK( std::distance( rbegin( vec ), rend( vec ) ) == std::distance( begin( vec ), end( vec ) ) );
+    const int                       ca[] = {1,2,3,4,5,6,7,8,9,10,11,12};
+    BOOST_CHECK( boost::rbegin( vec ) == boost::range_reverse_iterator<vec_t>::type( vec.end() ) );
+    BOOST_CHECK( boost::rend( vec ) == boost::range_reverse_iterator<vec_t>::type( vec.begin() ) );
+    BOOST_CHECK( std::distance( boost::rbegin( vec ), boost::rend( vec ) ) == std::distance( boost::begin( vec ), boost::end( vec ) ) );
 
-    BOOST_CHECK( rbegin( p ) == begin( rp ) );
-    BOOST_CHECK( rend( p ) == end( rp ) );
-    BOOST_CHECK( std::distance( rbegin( p ), rend( p ) ) == std::distance( begin( rp ), end( rp ) ) );
-    BOOST_CHECK( std::distance( begin( p ), end( p ) ) == std::distance( rbegin( rp ), rend( rp ) ) );
+    BOOST_CHECK( boost::rbegin( p ) == boost::begin( rp ) );
+    BOOST_CHECK( boost::rend( p ) == boost::end( rp ) );
+    BOOST_CHECK( std::distance( boost::rbegin( p ), boost::rend( p ) ) == std::distance( boost::begin( rp ), boost::end( rp ) ) );
+    BOOST_CHECK( std::distance( boost::begin( p ), boost::end( p ) ) == std::distance( boost::rbegin( rp ), boost::rend( rp ) ) );
 
 
-    BOOST_CHECK_EQUAL( &*begin( a ), &*( rend( a ) - 1 ) );
-    BOOST_CHECK_EQUAL( &*( end( a ) - 1 ), &*rbegin( a ) );
-    BOOST_CHECK_EQUAL( &*begin( ca ), &*( rend( ca ) - 1 ) );
-    BOOST_CHECK_EQUAL( &*( end( ca ) - 1 ), &*rbegin( ca ) );
+    BOOST_CHECK_EQUAL( &*boost::begin( a ), &*( boost::rend( a ) - 1 ) );
+    BOOST_CHECK_EQUAL( &*( boost::end( a ) - 1 ), &*boost::rbegin( a ) );
+    BOOST_CHECK_EQUAL( &*boost::begin( ca ), &*( boost::rend( ca ) - 1 ) );
+    BOOST_CHECK_EQUAL( &*( boost::end( ca ) - 1 ), &*boost::rbegin( ca ) );
 }
 
 
-using boost::unit_test::test_suite;
-
-test_suite* init_unit_test_suite( int argc, char* argv[] )
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
 {
-    test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
+    boost::unit_test::test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
 
     test->add( BOOST_TEST_CASE( &check_iterator ) );
 
diff --git a/test/std_container.cpp b/test/std_container.cpp
old mode 100755
new mode 100644
index e2ee692..9b8f284
--- a/test/std_container.cpp
+++ b/test/std_container.cpp
@@ -24,46 +24,43 @@
 #include <boost/test/test_tools.hpp>
 #include <vector>
 
-using namespace boost;
-
 void check_std_container()
 {
     typedef std::vector<int> vec_t;
     vec_t                    vec;
     vec.push_back( 3 ); vec.push_back( 4 );
-    const vec_t              cvec( vec ); 
+    const vec_t              cvec( vec );
 
-    BOOST_STATIC_ASSERT(( is_same< range_value<vec_t>::type, vec_t::value_type >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_iterator<vec_t>::type, vec_t::iterator >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_iterator<const vec_t>::type, vec_t::const_iterator >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_difference<vec_t>::type, vec_t::difference_type >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_size<vec_t>::type, vec_t::size_type >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_iterator<vec_t>::type, vec_t::iterator >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_iterator<const vec_t>::type, vec_t::const_iterator >::value ));
-    
-    BOOST_STATIC_ASSERT(( is_same< range_value<const vec_t>::type, vec_t::value_type >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_difference<const vec_t>::type, vec_t::difference_type >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_size<const vec_t>::type, vec_t::size_type >::value ));
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_value<vec_t>::type, vec_t::value_type >::value ));
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<vec_t>::type, vec_t::iterator >::value ));
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<const vec_t>::type, vec_t::const_iterator >::value ));
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_difference<vec_t>::type, vec_t::difference_type >::value ));
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_size<vec_t>::type, vec_t::size_type >::value ));
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<vec_t>::type, vec_t::iterator >::value ));
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<const vec_t>::type, vec_t::const_iterator >::value ));
 
-    BOOST_CHECK( begin( vec ) == vec.begin() );
-    BOOST_CHECK( end( vec )   == vec.end() );
-    BOOST_CHECK( empty( vec ) == vec.empty() );
-    BOOST_CHECK( (std::size_t)size( vec ) == vec.size() );
-    
-    BOOST_CHECK( begin( cvec ) == cvec.begin() );
-    BOOST_CHECK( end( cvec )   == cvec.end() );
-    BOOST_CHECK( empty( cvec ) == cvec.empty() );
-    BOOST_CHECK( (std::size_t)size( cvec ) == cvec.size() );
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_value<const vec_t>::type, vec_t::value_type >::value ));
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_difference<const vec_t>::type, vec_t::difference_type >::value ));
+    BOOST_STATIC_ASSERT(( boost::is_same< boost::range_size<const vec_t>::type, vec_t::size_type >::value ));
+
+    BOOST_CHECK( boost::begin( vec ) == vec.begin() );
+    BOOST_CHECK( boost::end( vec )   == vec.end() );
+    BOOST_CHECK( boost::empty( vec ) == vec.empty() );
+    BOOST_CHECK( static_cast<std::size_t>(boost::size( vec )) == vec.size() );
+
+    BOOST_CHECK( boost::begin( cvec ) == cvec.begin() );
+    BOOST_CHECK( boost::end( cvec )   == cvec.end() );
+    BOOST_CHECK( boost::empty( cvec ) == cvec.empty() );
+    BOOST_CHECK( static_cast<std::size_t>(boost::size( cvec )) == cvec.size() );
 
 }
 
 
 #include <boost/test/unit_test.hpp>
-using boost::unit_test::test_suite;
 
-test_suite* init_unit_test_suite( int argc, char* argv[] )
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
 {
-    test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
+    boost::unit_test::test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
 
     test->add( BOOST_TEST_CASE( &check_std_container ) );