diff --git a/test/algorithm_test/adjacent_find.cpp b/test/algorithm_test/adjacent_find.cpp
index 914736b..63b65e8 100644
--- a/test/algorithm_test/adjacent_find.cpp
+++ b/test/algorithm_test/adjacent_find.cpp
@@ -9,7 +9,7 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 #include <boost/range/algorithm/adjacent_find.hpp>
-
+#include <boost/range/iterator_range.hpp>
 #include <boost/test/test_tools.hpp>
 #include <boost/test/unit_test.hpp>
 
@@ -38,14 +38,18 @@ namespace boost
 
             BOOST_CHECK( boost::adjacent_find(cont) == cont.end() );
             BOOST_CHECK( boost::adjacent_find(cref_cont) == cref_cont.end() );
+            BOOST_CHECK( boost::adjacent_find(boost::make_iterator_range(cont)) == cont.end() );
             BOOST_CHECK( boost::adjacent_find(cont, pred) == cont.end() );
             BOOST_CHECK( boost::adjacent_find(cref_cont, pred) == cref_cont.end() );
+            BOOST_CHECK( boost::adjacent_find(boost::make_iterator_range(cont), pred) == cont.end() );
 
             cont += 1;
             BOOST_CHECK( boost::adjacent_find(cont) == cont.end() );
             BOOST_CHECK( boost::adjacent_find(cref_cont) == cref_cont.end() );
+            BOOST_CHECK( boost::adjacent_find(boost::make_iterator_range(cont)) == cont.end() );
             BOOST_CHECK( boost::adjacent_find(cont, pred) == cont.end() );
             BOOST_CHECK( boost::adjacent_find(cref_cont, pred) == cref_cont.end() );
+            BOOST_CHECK( boost::adjacent_find(boost::make_iterator_range(cont), pred) == cont.end() );
 
             cont += 2,3,4,5,5,5,6,7,8,9;
             iterator_t it = boost::adjacent_find(cont);
@@ -57,6 +61,8 @@ namespace boost
             {
                 BOOST_CHECK( *it == 5 );
             }
+            BOOST_CHECK( it == boost::adjacent_find(boost::make_iterator_range(cont)) );
+            BOOST_CHECK( it_pred == boost::adjacent_find(boost::make_iterator_range(cont), pred) );
             const_iterator_t cit = boost::adjacent_find(cref_cont);
             const_iterator_t cit_pred = boost::adjacent_find(cref_cont, pred);
             BOOST_CHECK( cit == cit_pred );
diff --git a/test/algorithm_test/binary_search.cpp b/test/algorithm_test/binary_search.cpp
index e0aca31..2646c2e 100644
--- a/test/algorithm_test/binary_search.cpp
+++ b/test/algorithm_test/binary_search.cpp
@@ -37,6 +37,8 @@ namespace boost
 
             BOOST_CHECK( reference_result == test_result );
 
+            BOOST_CHECK( test_result == boost::binary_search(boost::make_iterator_range(test), 5) );
+
             BOOST_CHECK_EQUAL_COLLECTIONS(
                 reference.begin(), reference.end(),
                 test.begin(), test.end()
@@ -68,6 +70,8 @@ namespace boost
 
             bool test_result = boost::binary_search(test, 5, pred);
 
+            BOOST_CHECK( test_result == boost::binary_search(boost::make_iterator_range(test), 5, pred) );
+
             BOOST_CHECK( reference_result == test_result );
 
             BOOST_CHECK_EQUAL_COLLECTIONS(
diff --git a/test/algorithm_test/copy.cpp b/test/algorithm_test/copy.cpp
index 932d190..47f4172 100644
--- a/test/algorithm_test/copy.cpp
+++ b/test/algorithm_test/copy.cpp
@@ -42,6 +42,13 @@ namespace boost
                 target.begin(), target.end(),
                 source.begin(), source.end()
                 );
+
+            it == boost::copy(boost::make_iterator_range(source), target.begin());
+            
+            BOOST_CHECK( it == target.end() );
+
+            BOOST_CHECK_EQUAL_COLLECTIONS(target.begin(), target.end(),
+                                          source.begin(), source.end());
         }
 
         void test_copy()
diff --git a/test/algorithm_test/copy_backward.cpp b/test/algorithm_test/copy_backward.cpp
index d66082a..3fd5679 100644
--- a/test/algorithm_test/copy_backward.cpp
+++ b/test/algorithm_test/copy_backward.cpp
@@ -39,6 +39,10 @@ namespace boost
             BOOST_CHECK( it == target.end() );
             BOOST_CHECK_EQUAL_COLLECTIONS( target.begin(), target.end(),
                 source.rbegin(), source.rend() );
+                
+            BOOST_CHECK( it == boost::copy_backward(boost::make_iterator_range(source), target.begin()) );
+            BOOST_CHECK_EQUAL_COLLECTIONS( target.begin(), target.end(),
+                                           source.rbegin(), source.rend() );
         }
 
         void test_copy_backward()
diff --git a/test/algorithm_test/copy_n.cpp b/test/algorithm_test/copy_n.cpp
index 59bca9b..230eb03 100644
--- a/test/algorithm_test/copy_n.cpp
+++ b/test/algorithm_test/copy_n.cpp
@@ -40,6 +40,13 @@ namespace
             target.begin(), target.end(),
             source.begin(), source.end()
             );
+
+        it = boost::copy(boost::make_iterator_range(source), target.begin());
+
+        BOOST_CHECK( it == target.end() );
+
+        BOOST_CHECK_EQUAL_COLLECTIONS(target.begin(), target.end(),
+                                      source.begin(), source.end());
     }
 
     void test_copy_n()
diff --git a/test/algorithm_test/count.cpp b/test/algorithm_test/count.cpp
index d364710..90b2090 100644
--- a/test/algorithm_test/count.cpp
+++ b/test/algorithm_test/count.cpp
@@ -31,28 +31,36 @@ namespace boost
             Container cont;
             const Container& cref_cont = cont;
 
-            BOOST_CHECK_EQUAL( 0u, boost::count(cont, 0) );
-            BOOST_CHECK_EQUAL( 0u, boost::count(cref_cont, 0) );
+            BOOST_CHECK_EQUAL( 0u, boost::count(cont, 0u) );
+            BOOST_CHECK_EQUAL( 0u, boost::count(cref_cont, 0u) );
+            BOOST_CHECK_EQUAL( 0u, boost::count(boost::make_iterator_range(cont), 0u) );
 
             cont += 1;
-            BOOST_CHECK_EQUAL( 0u, boost::count(cont, 0) );
-            BOOST_CHECK_EQUAL( 0u, boost::count(cref_cont, 0) );
-            BOOST_CHECK_EQUAL( 1u, boost::count(cont, 1) );
-            BOOST_CHECK_EQUAL( 1u, boost::count(cref_cont, 1) );
+            BOOST_CHECK_EQUAL( 0u, boost::count(cont, 0u) );
+            BOOST_CHECK_EQUAL( 0u, boost::count(cref_cont, 0u) );
+            BOOST_CHECK_EQUAL( 0u, boost::count(boost::make_iterator_range(cont), 0u) );
+            BOOST_CHECK_EQUAL( 1u, boost::count(cont, 1u) );
+            BOOST_CHECK_EQUAL( 1u, boost::count(cref_cont, 1u) );
+            BOOST_CHECK_EQUAL( 1u, boost::count(boost::make_iterator_range(cont), 1u) );
 
             cont += 2,3,4,5,6,7,8,9;
-            BOOST_CHECK_EQUAL( 0u, boost::count(cont, 0) );
-            BOOST_CHECK_EQUAL( 0u, boost::count(cref_cont, 0) );
-            BOOST_CHECK_EQUAL( 1u, boost::count(cont, 1) );
-            BOOST_CHECK_EQUAL( 1u, boost::count(cref_cont, 1) );
+            BOOST_CHECK_EQUAL( 0u, boost::count(cont, 0u) );
+            BOOST_CHECK_EQUAL( 0u, boost::count(cref_cont, 0u) );
+            BOOST_CHECK_EQUAL( 0u, boost::count(boost::make_iterator_range(cont), 0u) );
+            BOOST_CHECK_EQUAL( 1u, boost::count(cont, 1u) );
+            BOOST_CHECK_EQUAL( 1u, boost::count(cref_cont, 1u) );
+            BOOST_CHECK_EQUAL( 1u, boost::count(boost::make_iterator_range(cont), 1u) );
 
             cont += 2;
-            BOOST_CHECK_EQUAL( 0u, boost::count(cont, 0) );
-            BOOST_CHECK_EQUAL( 0u, boost::count(cref_cont, 0) );
-            BOOST_CHECK_EQUAL( 1u, boost::count(cont, 1) );
-            BOOST_CHECK_EQUAL( 1u, boost::count(cref_cont, 1) );
-            BOOST_CHECK_EQUAL( 2u, boost::count(cont, 2) );
-            BOOST_CHECK_EQUAL( 2u, boost::count(cref_cont, 2) );
+            BOOST_CHECK_EQUAL( 0u, boost::count(cont, 0u) );
+            BOOST_CHECK_EQUAL( 0u, boost::count(cref_cont, 0u) );
+            BOOST_CHECK_EQUAL( 0u, boost::count(boost::make_iterator_range(cont), 0u) );
+            BOOST_CHECK_EQUAL( 1u, boost::count(cont, 1u) );
+            BOOST_CHECK_EQUAL( 1u, boost::count(cref_cont, 1u) );
+            BOOST_CHECK_EQUAL( 1u, boost::count(boost::make_iterator_range(cont), 1u) );
+            BOOST_CHECK_EQUAL( 2u, boost::count(cont, 2u) );
+            BOOST_CHECK_EQUAL( 2u, boost::count(cref_cont, 2u) );
+            BOOST_CHECK_EQUAL( 2u, boost::count(boost::make_iterator_range(cont), 2u) );
         }
 
         void test_count()
diff --git a/test/algorithm_test/count_if.cpp b/test/algorithm_test/count_if.cpp
index 11526b4..c3d1b8b 100644
--- a/test/algorithm_test/count_if.cpp
+++ b/test/algorithm_test/count_if.cpp
@@ -15,6 +15,7 @@
 
 #include <boost/assign.hpp>
 #include "../test_function/false_predicate.hpp"
+#include "../test_function/true_predicate.hpp"
 #include "../test_function/equal_to_x.hpp"
 #include <algorithm>
 #include <list>
@@ -38,29 +39,42 @@ namespace boost
 
             BOOST_CHECK_EQUAL( 0u, boost::count_if(cont, pred_t(0)) );
             BOOST_CHECK_EQUAL( 0u, boost::count_if(cref_cont, pred_t(0)) );
+            BOOST_CHECK_EQUAL( 0u, boost::count_if(boost::make_iterator_range(cont), pred_t(0)) );
 
             cont += 1;
             BOOST_CHECK_EQUAL( 0u, boost::count_if(cont, pred_t(0)) );
             BOOST_CHECK_EQUAL( 0u, boost::count_if(cref_cont, pred_t(0)) );
+            BOOST_CHECK_EQUAL( 0u, boost::count_if(boost::make_iterator_range(cont), pred_t(0)) );
             BOOST_CHECK_EQUAL( 1u, boost::count_if(cont, pred_t(1)) );
             BOOST_CHECK_EQUAL( 1u, boost::count_if(cref_cont, pred_t(1)) );
+            BOOST_CHECK_EQUAL( 1u, boost::count_if(boost::make_iterator_range(cont), pred_t(1)) );
 
             cont += 2,3,4,5,6,7,8,9;
             BOOST_CHECK_EQUAL( 0u, boost::count_if(cont, pred_t(0)) );
             BOOST_CHECK_EQUAL( 0u, boost::count_if(cref_cont, pred_t(0)) );
+            BOOST_CHECK_EQUAL( 0u, boost::count_if(boost::make_iterator_range(cont), pred_t(0)) );
             BOOST_CHECK_EQUAL( 1u, boost::count_if(cont, pred_t(1)) );
             BOOST_CHECK_EQUAL( 1u, boost::count_if(cref_cont, pred_t(1)) );
+            BOOST_CHECK_EQUAL( 1u, boost::count_if(boost::make_iterator_range(cont), pred_t(1)) );
 
             cont += 2;
             BOOST_CHECK_EQUAL( 0u, boost::count_if(cont, pred_t(0)) );
             BOOST_CHECK_EQUAL( 0u, boost::count_if(cref_cont, pred_t(0)) );
+            BOOST_CHECK_EQUAL( 0u, boost::count_if(boost::make_iterator_range(cont), pred_t(0)) );
             BOOST_CHECK_EQUAL( 1u, boost::count_if(cont, pred_t(1)) );
             BOOST_CHECK_EQUAL( 1u, boost::count_if(cref_cont, pred_t(1)) );
+            BOOST_CHECK_EQUAL( 1u, boost::count_if(boost::make_iterator_range(cont), pred_t(1)) );
             BOOST_CHECK_EQUAL( 2u, boost::count_if(cont, pred_t(2)) );
             BOOST_CHECK_EQUAL( 2u, boost::count_if(cref_cont, pred_t(2)) );
+            BOOST_CHECK_EQUAL( 2u, boost::count_if(boost::make_iterator_range(cont), pred_t(2)) );
 
             BOOST_CHECK_EQUAL( 0u, boost::count_if(cont, false_predicate()) );
             BOOST_CHECK_EQUAL( 0u, boost::count_if(cref_cont, false_predicate()) );
+            BOOST_CHECK_EQUAL( 0u, boost::count_if(boost::make_iterator_range(cont), false_predicate()) );
+
+            BOOST_CHECK_EQUAL( cont.size(), boost::count_if(cont, true_predicate()) );
+            BOOST_CHECK_EQUAL( cont.size(), boost::count_if(cref_cont, true_predicate()) );
+            BOOST_CHECK_EQUAL( cont.size(), boost::count_if(boost::make_iterator_range(cont), true_predicate()) );
         }
 
         void test_count_if()
diff --git a/test/algorithm_test/equal.cpp b/test/algorithm_test/equal.cpp
index d750706..243f064 100644
--- a/test/algorithm_test/equal.cpp
+++ b/test/algorithm_test/equal.cpp
@@ -38,30 +38,70 @@ namespace boost
             Container2& cont2 = mcont2;
 
             BOOST_CHECK( boost::equal(cont1, cont2) );
+            BOOST_CHECK( boost::equal(boost::make_iterator_range(cont1), cont2) );
+            BOOST_CHECK( boost::equal(cont1, boost::make_iterator_range(cont2)) );
+            BOOST_CHECK( boost::equal(boost::make_iterator_range(cont1), boost::make_iterator_range(cont2)) );
             BOOST_CHECK( boost::equal(cont1, cont2, std::equal_to<int>()) );
+            BOOST_CHECK( boost::equal(boost::make_iterator_range(cont1), cont2, std::equal_to<int>()) );
+            BOOST_CHECK( boost::equal(cont1, boost::make_iterator_range(cont2), std::equal_to<int>()) );
+            BOOST_CHECK( boost::equal(boost::make_iterator_range(cont1), boost::make_iterator_range(cont2), std::equal_to<int>()) );
             BOOST_CHECK( boost::equal(cont1, cont2, std::not_equal_to<int>()) );
+            BOOST_CHECK( boost::equal(boost::make_iterator_range(cont1), cont2, std::not_equal_to<int>()) );
+            BOOST_CHECK( boost::equal(boost::make_iterator_range(cont1), boost::make_iterator_range(cont2), std::not_equal_to<int>()) );
 
             mcont1 += 1;
             BOOST_CHECK( !boost::equal(cont1, cont2) );
+            BOOST_CHECK( !boost::equal(boost::make_iterator_range(cont1), cont2) );
+            BOOST_CHECK( !boost::equal(cont1, boost::make_iterator_range(cont2)) );
+            BOOST_CHECK( !boost::equal(boost::make_iterator_range(cont1), boost::make_iterator_range(cont2)) );
             BOOST_CHECK( !boost::equal(cont1, cont2, std::equal_to<int>()) );
+            BOOST_CHECK( !boost::equal(boost::make_iterator_range(cont1), cont2, std::equal_to<int>()) );
+            BOOST_CHECK( !boost::equal(cont1, boost::make_iterator_range(cont2), std::equal_to<int>()) );
+            BOOST_CHECK( !boost::equal(boost::make_iterator_range(cont1), boost::make_iterator_range(cont2), std::equal_to<int>()) );
             BOOST_CHECK( !boost::equal(cont1, cont2, std::not_equal_to<int>()) );
+            BOOST_CHECK( !boost::equal(boost::make_iterator_range(cont1), cont2, std::not_equal_to<int>()) );
+            BOOST_CHECK( !boost::equal(boost::make_iterator_range(cont1), boost::make_iterator_range(cont2), std::not_equal_to<int>()) );
 
             mcont1.clear();
             mcont2 += 1;
             BOOST_CHECK( !boost::equal(cont1, cont2) );
+            BOOST_CHECK( !boost::equal(boost::make_iterator_range(cont1), cont2) );
+            BOOST_CHECK( !boost::equal(boost::make_iterator_range(cont1), boost::make_iterator_range(cont2)) );
             BOOST_CHECK( !boost::equal(cont1, cont2, std::equal_to<int>()) );
+            BOOST_CHECK( !boost::equal(boost::make_iterator_range(cont1), cont2, std::equal_to<int>()) );
+            BOOST_CHECK( !boost::equal(boost::make_iterator_range(cont1), boost::make_iterator_range(cont2), std::equal_to<int>()) );
             BOOST_CHECK( !boost::equal(cont1, cont2, std::not_equal_to<int>()) );
+            BOOST_CHECK( !boost::equal(boost::make_iterator_range(cont1), cont2, std::not_equal_to<int>()) );
+            BOOST_CHECK( !boost::equal(boost::make_iterator_range(cont1), boost::make_iterator_range(cont2), std::not_equal_to<int>()) );
 
             mcont1 += 1;
             BOOST_CHECK( boost::equal(cont1, cont2) );
+            BOOST_CHECK( boost::equal(boost::make_iterator_range(cont1), cont2) );
+            BOOST_CHECK( boost::equal(cont1, boost::make_iterator_range(cont2)) );
+            BOOST_CHECK( boost::equal(boost::make_iterator_range(cont1), boost::make_iterator_range(cont2)) );
             BOOST_CHECK( boost::equal(cont1, cont2, std::equal_to<int>()) );
+            BOOST_CHECK( boost::equal(boost::make_iterator_range(cont1), cont2, std::equal_to<int>()) );
+            BOOST_CHECK( boost::equal(cont1, boost::make_iterator_range(cont2), std::equal_to<int>()) );
+            BOOST_CHECK( boost::equal(boost::make_iterator_range(cont1), boost::make_iterator_range(cont2), std::equal_to<int>()) );
             BOOST_CHECK( !boost::equal(cont1, cont2, std::not_equal_to<int>()) );
+            BOOST_CHECK( !boost::equal(boost::make_iterator_range(cont1), cont2, std::not_equal_to<int>()) );
+            BOOST_CHECK( !boost::equal(cont1, boost::make_iterator_range(cont2), std::not_equal_to<int>()) );
+            BOOST_CHECK( !boost::equal(boost::make_iterator_range(cont1), boost::make_iterator_range(cont2), std::not_equal_to<int>()) );
 
             mcont1 += 2,3,4,5,6,7,8,9;
             mcont2 += 2,3,4,5,6,7,8,9;
             BOOST_CHECK( boost::equal(cont1, cont2) );
+            BOOST_CHECK( boost::equal(boost::make_iterator_range(cont1), cont2) );
+            BOOST_CHECK( boost::equal(cont1, boost::make_iterator_range(cont2)) );
+            BOOST_CHECK( boost::equal(boost::make_iterator_range(cont1), boost::make_iterator_range(cont2)) );
             BOOST_CHECK( boost::equal(cont1, cont2, std::equal_to<int>()) );
+            BOOST_CHECK( boost::equal(boost::make_iterator_range(cont1), cont2, std::equal_to<int>()) );
+            BOOST_CHECK( boost::equal(cont1, boost::make_iterator_range(cont2), std::equal_to<int>()) );
+            BOOST_CHECK( boost::equal(boost::make_iterator_range(cont1), boost::make_iterator_range(cont2), std::equal_to<int>()) );
             BOOST_CHECK( !boost::equal(cont1, cont2, std::not_equal_to<int>()) );
+            BOOST_CHECK( !boost::equal(boost::make_iterator_range(cont1), cont2, std::not_equal_to<int>()) );
+            BOOST_CHECK( !boost::equal(cont1, boost::make_iterator_range(cont2), std::not_equal_to<int>()) );
+            BOOST_CHECK( !boost::equal(boost::make_iterator_range(cont1), boost::make_iterator_range(cont2), std::not_equal_to<int>()) );
         }
 
         template< class Container1, class Container2 >
diff --git a/test/algorithm_test/equal_range.cpp b/test/algorithm_test/equal_range.cpp
index 652508c..612f1a4 100644
--- a/test/algorithm_test/equal_range.cpp
+++ b/test/algorithm_test/equal_range.cpp
@@ -70,8 +70,11 @@ namespace boost
 
             pair_t test_result = boost::equal_range(test, 5);
 
-            check_result(reference, reference_result,
-                         test, test_result);
+            check_result(reference, reference_result, test, test_result);
+
+            pair_t test_result2 = boost::equal_range(boost::make_iterator_range(test), 5);
+
+            check_result(reference, reference_result, test, test_result2);
         }
 
         template<class Container, class BinaryPredicate>
@@ -107,8 +110,11 @@ namespace boost
 
             pair_t test_result = boost::equal_range(test, 5, BinaryPredicate());
 
-            check_result(reference, reference_result,
-                         test, test_result);
+            check_result(reference, reference_result, test, test_result);
+
+            pair_t test_result2 = boost::equal_range(boost::make_iterator_range(test), 5, BinaryPredicate());
+
+            check_result(reference, reference_result, test, test_result2);
         }
 
         template<class Container>
diff --git a/test/algorithm_test/fill.cpp b/test/algorithm_test/fill.cpp
index 93dba7e..2f975c4 100644
--- a/test/algorithm_test/fill.cpp
+++ b/test/algorithm_test/fill.cpp
@@ -36,6 +36,12 @@ namespace boost
 
             BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
                 target.begin(), target.end() );
+
+            Container target2(cont);
+            boost::fill(boost::make_iterator_range(target2), 1);
+
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           target2.begin(), target2.end() );
         }
 
         template< class Container >
diff --git a/test/algorithm_test/find.cpp b/test/algorithm_test/find.cpp
index fd179f1..6eb1528 100644
--- a/test/algorithm_test/find.cpp
+++ b/test/algorithm_test/find.cpp
@@ -33,7 +33,11 @@ namespace boost
             BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
             test_iter(Container& cont)
             {
-                return boost::find(cont, 3);
+                typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iter_t;
+                iter_t result = boost::find(cont, 3);
+                iter_t result2 = boost::find(boost::make_iterator_range(cont), 3);
+                BOOST_CHECK( result == result2 );
+                return result;
             }
 
             template<range_return_value return_type>
@@ -43,7 +47,11 @@ namespace boost
                 BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
                 operator()(Policy&, Container& cont)
                 {
-                    return boost::find<return_type>(cont, 3);
+                    typedef BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type result_t;
+                    result_t result = boost::find<return_type>(cont, 3);
+                    result_t result2 = boost::find<return_type>(boost::make_iterator_range(cont), 3);
+                    BOOST_CHECK( result == result2 );
+                    return result;
                 }
             };
 
@@ -90,6 +98,8 @@ namespace boost
             std::vector<int> vi;
             const std::vector<int>& cvi = vi;
             std::vector<int>::const_iterator it = boost::find(vi, 0);
+            std::vector<int>::const_iterator it2 = boost::find(cvi, 0);
+            BOOST_CHECK( it == it2 );
         }
     }
 }
diff --git a/test/algorithm_test/find_end.cpp b/test/algorithm_test/find_end.cpp
index a126e87..0592d5f 100644
--- a/test/algorithm_test/find_end.cpp
+++ b/test/algorithm_test/find_end.cpp
@@ -41,7 +41,12 @@ namespace boost
             BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
             test_iter(Container& cont)
             {
-                return boost::find_end(cont, m_cont);
+                typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iter_t;
+                iter_t result = boost::find_end(cont, m_cont);
+                BOOST_CHECK( result == boost::find_end(boost::make_iterator_range(cont), m_cont) );
+                BOOST_CHECK( result == boost::find_end(cont, boost::make_iterator_range(m_cont)) );
+                BOOST_CHECK( result == boost::find_end(boost::make_iterator_range(cont), boost::make_iterator_range(m_cont)) );
+                return result;
             }
 
             template<range_return_value return_type>
@@ -51,7 +56,13 @@ namespace boost
                 BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
                 operator()(Policy& policy, Container& cont)
                 {
-                    return boost::find_end<return_type>(cont, policy.cont());
+                    typedef BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type result_t;
+                    result_t result = boost::find_end<return_type>(cont, policy.cont());
+                    BOOST_CHECK( result == boost::find_end<return_type>(boost::make_iterator_range(cont), policy.cont()) );
+                    BOOST_CHECK( result == boost::find_end<return_type>(cont, boost::make_iterator_range(policy.cont())) );
+                    BOOST_CHECK( result == boost::find_end<return_type>(boost::make_iterator_range(cont),
+                                                                        boost::make_iterator_range(policy.cont())) );
+                    return result;
                 }
             };
 
@@ -84,7 +95,12 @@ namespace boost
             BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
             test_iter(Container& cont)
             {
-                return boost::find_end(cont, m_cont, m_pred);
+                typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iter_t;
+                iter_t it = boost::find_end(cont, m_cont, m_pred);
+                BOOST_CHECK( it == boost::find_end(boost::make_iterator_range(cont), m_cont, m_pred) );
+                BOOST_CHECK( it == boost::find_end(cont, boost::make_iterator_range(m_cont), m_pred) );
+                BOOST_CHECK( it == boost::find_end(boost::make_iterator_range(cont), boost::make_iterator_range(m_cont), m_pred) );
+                return it;
             }
 
             template<range_return_value return_type>
@@ -94,6 +110,12 @@ namespace boost
                 BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
                 operator()(Policy& policy, Container& cont)
                 {
+                    typedef BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type result_t;
+                    result_t result = boost::find_end<return_type>(cont, policy.cont(), policy.pred());
+                    BOOST_CHECK( result == boost::find_end<return_type>(boost::make_iterator_range(cont), policy.cont(), policy.pred()) );
+                    BOOST_CHECK( result == boost::find_end<return_type>(cont, boost::make_iterator_range(policy.cont()), policy.pred()) );
+                    BOOST_CHECK( result == boost::find_end<return_type>(boost::make_iterator_range(cont),
+                                                                        boost::make_iterator_range(policy.cont()), policy.pred()) );
                     return boost::find_end<return_type>(cont, policy.cont(), policy.pred());
                 }
             };
diff --git a/test/algorithm_test/find_first_of.cpp b/test/algorithm_test/find_first_of.cpp
index 9ff7adb..c96d36a 100644
--- a/test/algorithm_test/find_first_of.cpp
+++ b/test/algorithm_test/find_first_of.cpp
@@ -41,7 +41,12 @@ namespace boost
             BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
             test_iter(Container& cont)
             {
-                return boost::find_first_of(cont, m_cont);
+                typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iter_t;
+                iter_t result = boost::find_first_of(cont, m_cont);
+                BOOST_CHECK( result == boost::find_first_of(boost::make_iterator_range(cont), m_cont) );
+                BOOST_CHECK( result == boost::find_first_of(cont, boost::make_iterator_range(m_cont)) );
+                BOOST_CHECK( result == boost::find_first_of(boost::make_iterator_range(cont), boost::make_iterator_range(m_cont)) );
+                return result;
             }
 
             template<range_return_value return_type>
@@ -51,7 +56,12 @@ namespace boost
                 BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
                 operator()(Policy& policy, Container& cont)
                 {
-                    return boost::find_first_of<return_type>(cont, policy.cont());
+                    typedef BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type result_t;
+                    result_t result = boost::find_first_of<return_type>(cont, policy.cont());
+                    BOOST_CHECK( result == boost::find_first_of<return_type>(boost::make_iterator_range(cont), policy.cont()) );
+                    BOOST_CHECK( result == boost::find_first_of<return_type>(cont, boost::make_iterator_range(policy.cont())) );
+                    BOOST_CHECK( result == boost::find_first_of<return_type>(boost::make_iterator_range(cont), boost::make_iterator_range(policy.cont())) );
+                    return result;
                 }
             };
 
@@ -84,7 +94,12 @@ namespace boost
             BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
             test_iter(Container& cont)
             {
-                return boost::find_first_of(cont, m_cont, m_pred);
+                typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iter_t;
+                iter_t result = boost::find_first_of(cont, m_cont, m_pred);
+                BOOST_CHECK( result == boost::find_first_of(boost::make_iterator_range(cont), m_cont, m_pred) );
+                BOOST_CHECK( result == boost::find_first_of(cont, boost::make_iterator_range(m_cont), m_pred) );
+                BOOST_CHECK( result == boost::find_first_of(boost::make_iterator_range(cont), boost::make_iterator_range(m_cont), m_pred) );
+                return result;
             }
 
             template<range_return_value return_type>
@@ -94,7 +109,12 @@ namespace boost
                 BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
                 operator()(Policy& policy, Container& cont)
                 {
-                    return boost::find_first_of<return_type>(cont, policy.cont(), policy.pred());
+                    typedef BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type result_t;
+                    result_t result = boost::find_first_of<return_type>(cont, policy.cont(), policy.pred());
+                    BOOST_CHECK( result == boost::find_first_of<return_type>(boost::make_iterator_range(cont), policy.cont(), policy.pred()) );
+                    BOOST_CHECK( result == boost::find_first_of<return_type>(cont, boost::make_iterator_range(policy.cont()), policy.pred()) );
+                    BOOST_CHECK( result == boost::find_first_of<return_type>(boost::make_iterator_range(cont), boost::make_iterator_range(policy.cont()), policy.pred()) );
+                    return result;
                 }
             };
 
@@ -103,8 +123,8 @@ namespace boost
             reference(Container& cont)
             {
                 return std::find_first_of(cont.begin(), cont.end(),
-                                     m_cont.begin(), m_cont.end(),
-                                     m_pred);
+                                          m_cont.begin(), m_cont.end(),
+                                          m_pred);
             }
 
         private:
diff --git a/test/algorithm_test/find_if.cpp b/test/algorithm_test/find_if.cpp
index a5fe459..04fe6f2 100644
--- a/test/algorithm_test/find_if.cpp
+++ b/test/algorithm_test/find_if.cpp
@@ -38,7 +38,10 @@ namespace boost
             BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
             test_iter(Container& cont)
             {
-                return boost::find_if(cont, m_pred);
+                typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iter_t;
+                iter_t result = boost::find_if(cont, m_pred);
+                BOOST_CHECK( result == boost::find_if(boost::make_iterator_range(cont), m_pred) );
+                return result;
             }
 
             template<range_return_value return_type>
@@ -48,7 +51,10 @@ namespace boost
                 BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
                 operator()(find_if_test_policy& policy, Container& cont)
                 {
-                    return boost::find_if<return_type>(cont, policy.pred());
+                    typedef BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type result_t;
+                    result_t result = boost::find_if<return_type>(cont, policy.pred());
+                    BOOST_CHECK( result == boost::find_if<return_type>(boost::make_iterator_range(cont), policy.pred()) );
+                    return result;
                 }
             };
 
diff --git a/test/algorithm_test/for_each.cpp b/test/algorithm_test/for_each.cpp
index 37614ad..2ef51bf 100644
--- a/test/algorithm_test/for_each.cpp
+++ b/test/algorithm_test/for_each.cpp
@@ -42,6 +42,9 @@ namespace boost
             // Test the mutable version
             fn_t result_fn = boost::for_each(rng, fn_t(rng));
             BOOST_CHECK_EQUAL( boost::udistance(rng), result_fn.invocation_count() );
+            
+            fn_t result_fn2 = boost::for_each(boost::make_iterator_range(rng), fn_t(rng));
+            BOOST_CHECK_EQUAL( boost::udistance(rng), result_fn.invocation_count() );
 
             // Test the constant version
             const SinglePassRange& cref_rng = rng;
diff --git a/test/algorithm_test/generate.cpp b/test/algorithm_test/generate.cpp
index ab47b06..d8fc0e6 100644
--- a/test/algorithm_test/generate.cpp
+++ b/test/algorithm_test/generate.cpp
@@ -49,6 +49,12 @@ namespace boost
 
             BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
                 test.begin(), test.end() );
+                
+            Container test2(cont);
+            boost::generate(boost::make_iterator_range(test2), generator_fn());
+            
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           test2.begin(), test2.end() );
         }
 
         template< class Container >
diff --git a/test/algorithm_test/heap.cpp b/test/algorithm_test/heap.cpp
index 933d1f6..74b7fa3 100644
--- a/test/algorithm_test/heap.cpp
+++ b/test/algorithm_test/heap.cpp
@@ -41,28 +41,39 @@ namespace boost
             reference += 1,2,3,4,5,6,7,8,9;
 
             std::vector<int> test_cont(reference);
+            std::vector<int> test_cont2(reference);
 
             std::make_heap(reference.begin(), reference.end());
             boost::make_heap(test_cont);
             check_equal(reference, test_cont);
+            boost::make_heap(boost::make_iterator_range(test_cont2));
+            check_equal(reference, test_cont2);
 
             std::push_heap(reference.begin(), reference.end());
             boost::push_heap(test_cont);
             check_equal(reference, test_cont);
+            boost::push_heap(boost::make_iterator_range(test_cont2));
+            check_equal(reference, test_cont2);
 
             std::make_heap(reference.begin(), reference.end());
             boost::make_heap(test_cont);
+            boost::make_heap(boost::make_iterator_range(test_cont2));
 
             std::sort_heap(reference.begin(), reference.end());
             boost::sort_heap(test_cont);
             check_equal(reference, test_cont);
+            boost::sort_heap(boost::make_iterator_range(test_cont2));
+            check_equal(reference, test_cont2);
 
             std::make_heap(reference.begin(), reference.end());
             boost::make_heap(test_cont);
+            boost::make_heap(boost::make_iterator_range(test_cont2));
 
             std::pop_heap(reference.begin(), reference.end());
             boost::pop_heap(test_cont);
             check_equal(reference, test_cont);
+            boost::pop_heap(boost::make_iterator_range(test_cont2));
+            check_equal(reference, test_cont2);
         }
 
         template<class BinaryPredicate>
@@ -75,30 +86,42 @@ namespace boost
             std::sort(reference.begin(), reference.end(), pred);
 
             std::vector<int> test_cont(reference);
+            std::vector<int> test_cont2(reference);
 
             std::make_heap(reference.begin(), reference.end(), pred);
             boost::make_heap(test_cont, pred);
             check_equal(reference, test_cont);
+            boost::make_heap(boost::make_iterator_range(test_cont2), pred);
+            check_equal(reference, test_cont2);
 
             reference.push_back(5);
             test_cont.push_back(5);
+            test_cont2.push_back(5);
             std::push_heap(reference.begin(), reference.end(), pred);
             boost::push_heap(test_cont, pred);
             check_equal(reference, test_cont);
+            boost::push_heap(boost::make_iterator_range(test_cont2), pred);
+            check_equal(reference, test_cont2);
 
             std::make_heap(reference.begin(), reference.end(), pred);
             boost::make_heap(test_cont, pred);
+            boost::make_heap(boost::make_iterator_range(test_cont2), pred);
 
             std::sort_heap(reference.begin(), reference.end(), pred);
             boost::sort_heap(test_cont, pred);
             check_equal(reference, test_cont);
+            boost::sort_heap(boost::make_iterator_range(test_cont2), pred);
+            check_equal(reference, test_cont2);
 
             std::make_heap(reference.begin(), reference.end(), pred);
             boost::make_heap(test_cont, pred);
+            boost::make_heap(boost::make_iterator_range(test_cont2), pred);
 
             std::pop_heap(reference.begin(), reference.end(), pred);
             boost::pop_heap(test_cont, pred);
             check_equal(reference, test_cont);
+            boost::pop_heap(boost::make_iterator_range(test_cont2), pred);
+            check_equal(reference, test_cont2);
         }
 
         void test_heap()
diff --git a/test/algorithm_test/includes.cpp b/test/algorithm_test/includes.cpp
index f928957..8977532 100644
--- a/test/algorithm_test/includes.cpp
+++ b/test/algorithm_test/includes.cpp
@@ -46,6 +46,10 @@ namespace boost
                 old_cont2.begin(), old_cont2.end(),
                 cont2.begin(), cont2.end()
                 );
+                
+            BOOST_CHECK( test_result == boost::includes(boost::make_iterator_range(cont1), cont2) );
+            BOOST_CHECK( test_result == boost::includes(cont1, boost::make_iterator_range(cont2)) );
+            BOOST_CHECK( test_result == boost::includes(boost::make_iterator_range(cont1), boost::make_iterator_range(cont2)) );
         }
 
         template<class Container, class BinaryPredicate>
@@ -88,6 +92,10 @@ namespace boost
                 old_cont2.begin(), old_cont2.end(),
                 cont2.begin(), cont2.end()
                 );
+                
+            BOOST_CHECK( test_result == boost::includes(boost::make_iterator_range(cont1), cont2, pred) );
+            BOOST_CHECK( test_result == boost::includes(cont1, boost::make_iterator_range(cont2), pred) );
+            BOOST_CHECK( test_result == boost::includes(boost::make_iterator_range(cont1), boost::make_iterator_range(cont2), pred) );
         }
 
         template<class Container1, class Container2>
diff --git a/test/algorithm_test/inplace_merge.cpp b/test/algorithm_test/inplace_merge.cpp
index f109257..d0cad73 100644
--- a/test/algorithm_test/inplace_merge.cpp
+++ b/test/algorithm_test/inplace_merge.cpp
@@ -35,6 +35,7 @@ namespace boost
                                     cont2.begin(), cont2.end());
 
             std::vector<value_t> test_target(reference_target);
+            std::vector<value_t> test_target2(reference_target);
 
             std::inplace_merge(reference_target.begin(),
                                reference_target.begin() + cont1.size(),
@@ -47,6 +48,14 @@ namespace boost
                 reference_target.begin(), reference_target.end(),
                 test_target.begin(), test_target.end()
                 );
+                
+            boost::inplace_merge(boost::make_iterator_range(test_target2),
+                                 test_target2.begin() + cont1.size());
+                                 
+            BOOST_CHECK_EQUAL_COLLECTIONS(
+                reference_target.begin(), reference_target.end(),
+                test_target2.begin(), test_target2.end()
+                );
         }
 
         template<class Container, class BinaryPredicate>
@@ -75,6 +84,7 @@ namespace boost
                                     cont2.begin(), cont2.end());
 
             std::vector<value_t> test_target(reference_target);
+            std::vector<value_t> test_target2(reference_target);
 
             std::inplace_merge(reference_target.begin(),
                                reference_target.begin() + cont1.size(),
@@ -88,6 +98,15 @@ namespace boost
                 reference_target.begin(), reference_target.end(),
                 test_target.begin(), test_target.end()
                 );
+
+            boost::inplace_merge(boost::make_iterator_range(test_target2),
+                                 test_target2.begin() + cont1.size(),
+                                 pred);
+                                 
+            BOOST_CHECK_EQUAL_COLLECTIONS(
+                reference_target.begin(), reference_target.end(),
+                test_target2.begin(), test_target2.end()
+                );
         }
 
         template<class Container1, class Container2>
diff --git a/test/algorithm_test/lexicographical_compare.cpp b/test/algorithm_test/lexicographical_compare.cpp
index c57f390..f724bd1 100644
--- a/test/algorithm_test/lexicographical_compare.cpp
+++ b/test/algorithm_test/lexicographical_compare.cpp
@@ -28,13 +28,16 @@ namespace boost
         void test_lexicographical_compare_impl_nopred(ForwardRange1& rng1,
                                                       ForwardRange2& rng2)
         {
-            bool reference = std::lexicographical_compare(
+            const bool reference = std::lexicographical_compare(
                 boost::begin(rng1), boost::end(rng1),
                 boost::begin(rng2), boost::end(rng2));
 
-            bool test = boost::lexicographical_compare(rng1, rng2);
+            const bool test = boost::lexicographical_compare(rng1, rng2);
 
             BOOST_CHECK( reference == test );
+            BOOST_CHECK( test == boost::lexicographical_compare(boost::make_iterator_range(rng1), rng2) );
+            BOOST_CHECK( test == boost::lexicographical_compare(rng1, boost::make_iterator_range(rng2)) );
+            BOOST_CHECK( test == boost::lexicographical_compare(boost::make_iterator_range(rng1), boost::make_iterator_range(rng2)) );
         }
 
         template<class ForwardRange1, class ForwardRange2,
@@ -43,14 +46,17 @@ namespace boost
                                                     ForwardRange2& rng2,
                                                     BinaryPredicate pred)
         {
-            bool reference = std::lexicographical_compare(
+            const bool reference = std::lexicographical_compare(
                 boost::begin(rng1), boost::end(rng1),
                 boost::begin(rng2), boost::end(rng2),
                 pred);
 
-            bool test = boost::lexicographical_compare(rng1, rng2, pred);
+            const bool test = boost::lexicographical_compare(rng1, rng2, pred);
 
             BOOST_CHECK( reference == test );
+            BOOST_CHECK( test == boost::lexicographical_compare(boost::make_iterator_range(rng1), rng2, pred) );
+            BOOST_CHECK( test == boost::lexicographical_compare(rng1, boost::make_iterator_range(rng2), pred) );
+            BOOST_CHECK( test == boost::lexicographical_compare(boost::make_iterator_range(rng1), boost::make_iterator_range(rng2), pred) );
         }
 
         template<class Container1, class Container2>
diff --git a/test/algorithm_test/lower_bound.cpp b/test/algorithm_test/lower_bound.cpp
index ca622bc..e627708 100644
--- a/test/algorithm_test/lower_bound.cpp
+++ b/test/algorithm_test/lower_bound.cpp
@@ -33,7 +33,10 @@ namespace boost
             BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
             test_iter(Container& cont)
             {
-                return boost::lower_bound(cont, 5);
+                typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iter_t;
+                iter_t result = boost::lower_bound(cont, 5);
+                BOOST_CHECK( result == boost::lower_bound(boost::make_iterator_range(cont), 5) );
+                return result;
             }
 
             template<range_return_value return_type>
@@ -43,7 +46,10 @@ namespace boost
                 BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
                 operator()(Policy&, Container& cont)
                 {
-                    return boost::lower_bound<return_type>(cont, 5);
+                    typedef BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type result_t;
+                    result_t result = boost::lower_bound<return_type>(cont, 5);
+                    BOOST_CHECK( result == boost::lower_bound<return_type>(boost::make_iterator_range(cont), 5) );
+                    return result;
                 }
             };
 
@@ -62,7 +68,11 @@ namespace boost
             BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
             test_iter(Container& cont)
             {
-                return boost::lower_bound(cont, 5, m_pred);
+                typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iter_t;
+                iter_t result = boost::lower_bound(cont, 5, m_pred);
+                BOOST_CHECK( result == boost::lower_bound(
+                                        boost::make_iterator_range(cont), 5, m_pred) );
+                return result;
             }
 
             template< range_return_value return_type >
@@ -72,8 +82,11 @@ namespace boost
                 BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
                 operator()(Policy& policy, Container& cont)
                 {
-                    return boost::lower_bound<return_type>(
-                        cont, 5, policy.pred());
+                    typedef BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type result_t;
+                    result_t result = boost::lower_bound<return_type>(cont, 5, policy.pred());
+                    BOOST_CHECK( result == boost::lower_bound<return_type>(
+                                            boost::make_iterator_range(cont), 5, policy.pred()) );
+                    return result;
                 }
             };
 
diff --git a/test/algorithm_test/max_element.cpp b/test/algorithm_test/max_element.cpp
index d4c70ca..c4c6cb9 100644
--- a/test/algorithm_test/max_element.cpp
+++ b/test/algorithm_test/max_element.cpp
@@ -33,7 +33,11 @@ namespace boost
             BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
             test_iter(Container& cont)
             {
-                return boost::max_element(cont);
+                typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iter_t;
+                iter_t result = boost::max_element(cont);
+                BOOST_CHECK( result == boost::max_element(
+                                            boost::make_iterator_range(cont)) );
+                return result;
             }
 
             template<range_return_value return_type>
@@ -43,7 +47,11 @@ namespace boost
                 BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
                 operator()(Policy&, Container& cont)
                 {
-                    return boost::max_element<return_type>(cont);
+                    typedef BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type result_t;
+                    result_t result = boost::max_element<return_type>(cont);
+                    BOOST_CHECK( result == boost::max_element<return_type>(
+                                                boost::make_iterator_range(cont)) );
+                    return result;
                 }
             };
 
@@ -63,7 +71,11 @@ namespace boost
             BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
             test_iter(Container& cont)
             {
-                return boost::max_element(cont, Pred());
+                typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iter_t;
+                iter_t result = boost::max_element(cont, Pred());
+                BOOST_CHECK( result == boost::max_element(
+                                            boost::make_iterator_range(cont), Pred()) );
+                return result;
             }
 
             Pred pred() const { return Pred(); }
@@ -75,7 +87,11 @@ namespace boost
                 BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
                 operator()(Policy& policy, Container& cont)
                 {
-                    return boost::max_element<return_type>(cont, policy.pred());
+                    typedef BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type result_t;
+                    result_t result = boost::max_element<return_type>(cont, policy.pred());
+                    BOOST_CHECK( result == boost::max_element<return_type>(
+                                                boost::make_iterator_range(cont), policy.pred()) );
+                    return result;
                 }
             };
 
diff --git a/test/algorithm_test/merge.cpp b/test/algorithm_test/merge.cpp
index aed7cd7..5038782 100644
--- a/test/algorithm_test/merge.cpp
+++ b/test/algorithm_test/merge.cpp
@@ -51,6 +51,46 @@ namespace boost
                 reference_target.begin(), reference_target.end(),
                 test_target.begin(), test_target.end()
                 );
+                
+            test_it = boost::merge(boost::make_iterator_range(cont1),
+                                   cont2, test_target.begin());
+                                   
+            BOOST_CHECK_EQUAL(
+                std::distance<iterator_t>(reference_target.begin(), reference_it),
+                std::distance<iterator_t>(test_target.begin(), test_it)
+                );
+                
+            BOOST_CHECK_EQUAL_COLLECTIONS(
+                reference_target.begin(), reference_target.end(),
+                test_target.begin(), test_target.end()
+                );
+                
+            test_it = boost::merge(cont1, boost::make_iterator_range(cont2),
+                                   test_target.begin());
+                                   
+            BOOST_CHECK_EQUAL(
+                std::distance<iterator_t>(reference_target.begin(), reference_it),
+                std::distance<iterator_t>(test_target.begin(), test_it)
+                );
+                
+            BOOST_CHECK_EQUAL_COLLECTIONS(
+                reference_target.begin(), reference_target.end(),
+                test_target.begin(), test_target.end()
+                );
+                
+            test_it = boost::merge(boost::make_iterator_range(cont1),
+                                   boost::make_iterator_range(cont2),
+                                   test_target.begin());
+                                   
+            BOOST_CHECK_EQUAL(
+                std::distance<iterator_t>(reference_target.begin(), reference_it),
+                std::distance<iterator_t>(test_target.begin(), test_it)
+                );
+                
+            BOOST_CHECK_EQUAL_COLLECTIONS(
+                reference_target.begin(), reference_target.end(),
+                test_target.begin(), test_target.end()
+                );
         }
 
         template<class Container, class BinaryPredicate>
@@ -95,6 +135,46 @@ namespace boost
                 reference_target.begin(), reference_target.end(),
                 test_target.begin(), test_target.end()
                 );
+                
+            test_it = boost::merge(boost::make_iterator_range(cont1), cont2,
+                                   test_target.begin(), pred);
+                                   
+            BOOST_CHECK_EQUAL(
+                std::distance(reference_target.begin(), reference_it),
+                std::distance(test_target.begin(), test_it)
+                );
+                
+            BOOST_CHECK_EQUAL_COLLECTIONS(
+                reference_target.begin(), reference_target.end(),
+                test_target.begin(), test_target.end()
+                );
+                
+            test_it = boost::merge(cont1, boost::make_iterator_range(cont2),
+                                   test_target.begin(), pred);
+                                   
+            BOOST_CHECK_EQUAL(
+                std::distance(reference_target.begin(), reference_it),
+                std::distance(test_target.begin(), test_it)
+                );
+                
+            BOOST_CHECK_EQUAL_COLLECTIONS(
+                reference_target.begin(), reference_target.end(),
+                test_target.begin(), test_target.end()
+                );
+                
+            test_it = boost::merge(boost::make_iterator_range(cont1),
+                                   boost::make_iterator_range(cont2),
+                                   test_target.begin(), pred);
+                                   
+            BOOST_CHECK_EQUAL(
+                std::distance(reference_target.begin(), reference_it),
+                std::distance(test_target.begin(), test_it)
+                );
+                
+            BOOST_CHECK_EQUAL_COLLECTIONS(
+                reference_target.begin(), reference_target.end(),
+                test_target.begin(), test_target.end()
+                );
         }
 
         template<class Container1, class Container2>
diff --git a/test/algorithm_test/min_element.cpp b/test/algorithm_test/min_element.cpp
index c68a655..c8fceda 100644
--- a/test/algorithm_test/min_element.cpp
+++ b/test/algorithm_test/min_element.cpp
@@ -33,7 +33,10 @@ namespace boost
             BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
             test_iter(Container& cont)
             {
-                return boost::min_element(cont);
+                typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iter_t;
+                iter_t result = boost::min_element(cont);
+                BOOST_CHECK( result == boost::min_element(boost::make_iterator_range(cont)) );
+                return result;
             }
 
             template< range_return_value return_type >
@@ -43,7 +46,10 @@ namespace boost
                 BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
                 operator()(Policy&, Container& cont)
                 {
-                    return boost::min_element<return_type>(cont);
+                    typedef BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type result_t;
+                    result_t result = boost::min_element<return_type>(cont);
+                    BOOST_CHECK( result == boost::min_element<return_type>(boost::make_iterator_range(cont)) );
+                    return result;
                 }
             };
 
@@ -63,7 +69,11 @@ namespace boost
             BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
             test_iter(Container& cont)
             {
-                return boost::min_element(cont, Pred());
+                typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iter_t;
+                iter_t result = boost::min_element(cont, Pred());
+                BOOST_CHECK( result == boost::min_element(
+                                        boost::make_iterator_range(cont), Pred()) );
+                return result;
             }
 
             Pred pred() const { return Pred(); }
@@ -75,7 +85,11 @@ namespace boost
                 BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
                 operator()(Policy& policy, Container& cont)
                 {
-                    return boost::min_element<return_type>(cont, policy.pred());
+                    typedef BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type result_t;
+                    result_t result = boost::min_element<return_type>(cont, policy.pred());
+                    BOOST_CHECK( result == boost::min_element<return_type>(
+                                    boost::make_iterator_range(cont), policy.pred()) );
+                    return result;
                 }
             };
 
diff --git a/test/algorithm_test/mismatch.cpp b/test/algorithm_test/mismatch.cpp
index eb8f5e7..2336e59 100644
--- a/test/algorithm_test/mismatch.cpp
+++ b/test/algorithm_test/mismatch.cpp
@@ -23,6 +23,130 @@ namespace boost
 {
     namespace
     {
+        template< class Container1, class Container2 >
+        void eval_mismatch(Container1& cont1,
+                           Container2& cont2,
+                           BOOST_DEDUCED_TYPENAME range_iterator<Container1>::type ref_it1,
+                           BOOST_DEDUCED_TYPENAME range_iterator<Container2>::type ref_it2
+                           )
+        {
+            typedef BOOST_DEDUCED_TYPENAME range_iterator<Container1>::type iter1_t;
+            typedef BOOST_DEDUCED_TYPENAME range_iterator<Container2>::type iter2_t;
+            typedef std::pair<iter1_t, iter2_t> result_pair_t;
+            
+            result_pair_t result = boost::mismatch(cont1, cont2);
+            BOOST_CHECK( result.first == ref_it1 );
+            BOOST_CHECK( result.second == ref_it2 );
+            
+            result = boost::mismatch(boost::make_iterator_range(cont1),
+                                     cont2);
+            BOOST_CHECK( result.first == ref_it1 );
+            BOOST_CHECK( result.second == ref_it2 );
+            
+            result = boost::mismatch(cont1,
+                                     boost::make_iterator_range(cont2));
+            BOOST_CHECK( result.first == ref_it1 );
+            BOOST_CHECK( result.second == ref_it2 );
+            
+            result = boost::mismatch(boost::make_iterator_range(cont1),
+                                     boost::make_iterator_range(cont2));
+            BOOST_CHECK( result.first == ref_it1 );
+            BOOST_CHECK( result.second == ref_it2 );
+        }
+        
+        template< class Container1, class Container2, class Pred >
+        void eval_mismatch(Container1& cont1,
+                           Container2& cont2,
+                           Pred pred,
+                           BOOST_DEDUCED_TYPENAME range_iterator<Container1>::type ref_it1,
+                           BOOST_DEDUCED_TYPENAME range_iterator<Container2>::type ref_it2
+                           )
+        {
+            typedef BOOST_DEDUCED_TYPENAME range_iterator<Container1>::type iter1_t;
+            typedef BOOST_DEDUCED_TYPENAME range_iterator<Container2>::type iter2_t;
+            typedef std::pair<iter1_t, iter2_t> result_pair_t;
+            
+            result_pair_t result = boost::mismatch(cont1, cont2, pred);
+            BOOST_CHECK( result.first == ref_it1 );
+            BOOST_CHECK( result.second == ref_it2 );
+            
+            result = boost::mismatch(boost::make_iterator_range(cont1),
+                                     cont2, pred);
+            BOOST_CHECK( result.first == ref_it1 );
+            BOOST_CHECK( result.second == ref_it2 );
+            
+            result = boost::mismatch(cont1,
+                                     boost::make_iterator_range(cont2), pred);
+            BOOST_CHECK( result.first == ref_it1 );
+            BOOST_CHECK( result.second == ref_it2 );
+            
+            result = boost::mismatch(boost::make_iterator_range(cont1),
+                                     boost::make_iterator_range(cont2),
+                                     pred);
+            BOOST_CHECK( result.first == ref_it1 );
+            BOOST_CHECK( result.second == ref_it2 );
+        }
+        
+        template< class Container1, class Container2 >
+        void eval_mismatch(Container1& cont1,
+                           Container2& cont2,
+                           const int ref1,
+                           const int ref2)
+        {
+            typedef BOOST_DEDUCED_TYPENAME range_iterator<Container1>::type iter1_t;
+            typedef BOOST_DEDUCED_TYPENAME range_iterator<Container2>::type iter2_t;
+            typedef std::pair<iter1_t, iter2_t> result_pair_t;
+            
+            result_pair_t result = boost::mismatch(cont1, cont2);
+            BOOST_CHECK_EQUAL( ref1, *result.first );
+            BOOST_CHECK_EQUAL( ref2, *result.second );
+            
+            result = boost::mismatch(boost::make_iterator_range(cont1), cont2);
+            BOOST_CHECK_EQUAL( ref1, *result.first );
+            BOOST_CHECK_EQUAL( ref2, *result.second );
+            
+            result = boost::mismatch(cont1, boost::make_iterator_range(cont2));
+            BOOST_CHECK_EQUAL( ref1, *result.first );
+            BOOST_CHECK_EQUAL( ref2, *result.second );
+            
+            result = boost::mismatch(boost::make_iterator_range(cont1),
+                                     boost::make_iterator_range(cont2));
+            BOOST_CHECK_EQUAL( ref1, *result.first );
+            BOOST_CHECK_EQUAL( ref2, *result.second );
+        }
+        
+        template< class Container1, class Container2, class Pred >
+        void eval_mismatch(Container1& cont1,
+                           Container2& cont2,
+                           Pred pred,
+                           const int ref1,
+                           const int ref2)
+        {
+            typedef BOOST_DEDUCED_TYPENAME range_iterator<Container1>::type iter1_t;
+            typedef BOOST_DEDUCED_TYPENAME range_iterator<Container2>::type iter2_t;
+            typedef std::pair<iter1_t, iter2_t> result_pair_t;
+            
+            result_pair_t result = boost::mismatch(cont1, cont2, pred);
+            BOOST_CHECK_EQUAL( ref1, *result.first );
+            BOOST_CHECK_EQUAL( ref2, *result.second );
+            
+            result = boost::mismatch(boost::make_iterator_range(cont1),
+                                     cont2, pred);
+            BOOST_CHECK_EQUAL( ref1, *result.first );
+            BOOST_CHECK_EQUAL( ref2, *result.second );
+            
+            result = boost::mismatch(cont1, boost::make_iterator_range(cont2),
+                                     pred);
+            BOOST_CHECK_EQUAL( ref1, *result.first );
+            BOOST_CHECK_EQUAL( ref2, *result.second );
+            
+            result = boost::mismatch(boost::make_iterator_range(cont1),
+                                     boost::make_iterator_range(cont2),
+                                     pred);
+            BOOST_CHECK_EQUAL( ref1, *result.first );
+            BOOST_CHECK_EQUAL( ref2, *result.second );
+        }
+        
         template< class Container1, class Container2 >
         void test_mismatch_impl()
         {
@@ -46,107 +170,42 @@ namespace boost
             typedef std::pair<iterator1_t,       const_iterator2_t> pair_mcit_t;
             typedef std::pair<const_iterator1_t, const_iterator2_t> pair_ccit_t;
 
-            pair_mmit_t pair_mmit = boost::mismatch(cont1, cont2);
-            BOOST_CHECK( pair_mmit.first == cont1.end() );
-            BOOST_CHECK( pair_mmit.second == cont2.end() );
-            pair_mmit = boost::mismatch(cont1, cont2, std::equal_to<int>());
-            BOOST_CHECK( pair_mmit.first == cont1.end() );
-            BOOST_CHECK( pair_mmit.second == cont2.end() );
-
-            pair_cmit_t pair_cmit = boost::mismatch(cref_cont1, cont2);
-            BOOST_CHECK( pair_cmit.first == cref_cont1.end() );
-            BOOST_CHECK( pair_cmit.second == cont2.end() );
-            pair_cmit = boost::mismatch(cref_cont1, cont2, std::equal_to<int>());
-            BOOST_CHECK( pair_cmit.first == cref_cont1.end() );
-            BOOST_CHECK( pair_cmit.second == cont2.end() );
-
-            pair_mcit_t pair_mcit = boost::mismatch(cont1, cref_cont2);
-            BOOST_CHECK( pair_mcit.first == cont1.end() );
-            BOOST_CHECK( pair_mcit.second == cref_cont2.end() );
-            pair_mcit = boost::mismatch(cont1, cref_cont2, std::equal_to<int>());
-            BOOST_CHECK( pair_mcit.first == cont1.end() );
-            BOOST_CHECK( pair_mcit.second == cref_cont2.end() );
-
-            pair_ccit_t pair_ccit = boost::mismatch(cref_cont1, cref_cont2);
-            BOOST_CHECK( pair_ccit.first == cref_cont1.end() );
-            BOOST_CHECK( pair_ccit.second == cref_cont2.end() );
-            pair_ccit = boost::mismatch(cref_cont1, cref_cont2, std::equal_to<int>());
-            BOOST_CHECK( pair_ccit.first == cref_cont1.end() );
-            BOOST_CHECK( pair_ccit.second == cref_cont2.end() );
+            eval_mismatch(cont1, cont2, cont1.end(), cont2.end());
+            eval_mismatch(cont1, cont2, std::equal_to<int>(), cont1.end(), cont2.end());
+            eval_mismatch(cref_cont1, cont2, cref_cont1.end(), cont2.end());
+            eval_mismatch(cref_cont1, cont2, std::equal_to<int>(), cref_cont1.end(), cont2.end());
+            eval_mismatch(cont1, cref_cont2, cont1.end(), cref_cont2.end());
+            eval_mismatch(cont1, cref_cont2, std::equal_to<int>(), cont1.end(), cref_cont2.end());
+            eval_mismatch(cref_cont1, cref_cont2, cref_cont1.end(), cref_cont2.end());
+            eval_mismatch(cref_cont1, cref_cont2, std::equal_to<int>(), cref_cont1.end(), cref_cont2.end());
 
             cont1 += 1,2,3,4;
             cont2 += 1,2,3,4;
-            pair_mmit = boost::mismatch(cont1, cont2);
-            BOOST_CHECK( pair_mmit.first == cont1.end() );
-            BOOST_CHECK( pair_mmit.second == cont2.end() );
-            pair_mmit = boost::mismatch(cont1, cont2, std::equal_to<int>());
-            BOOST_CHECK( pair_mmit.first == cont1.end() );
-            BOOST_CHECK( pair_mmit.second == cont2.end() );
-
-            pair_cmit = boost::mismatch(cref_cont1, cont2);
-            BOOST_CHECK( pair_cmit.first == cref_cont1.end() );
-            BOOST_CHECK( pair_cmit.second == cont2.end() );
-            pair_cmit = boost::mismatch(cref_cont1, cont2, std::equal_to<int>());
-            BOOST_CHECK( pair_cmit.first == cref_cont1.end() );
-            BOOST_CHECK( pair_cmit.second == cont2.end() );
-
-            pair_mcit = boost::mismatch(cont1, cref_cont2);
-            BOOST_CHECK( pair_mcit.first == cont1.end() );
-            BOOST_CHECK( pair_mcit.second == cref_cont2.end() );
-            pair_mcit = boost::mismatch(cont1, cref_cont2, std::equal_to<int>());
-            BOOST_CHECK( pair_mcit.first == cont1.end() );
-            BOOST_CHECK( pair_mcit.second == cref_cont2.end() );
-
-            pair_ccit = boost::mismatch(cref_cont1, cref_cont2);
-            BOOST_CHECK( pair_ccit.first == cref_cont1.end() );
-            BOOST_CHECK( pair_ccit.second == cref_cont2.end() );
-            pair_ccit = boost::mismatch(cref_cont1, cref_cont2, std::equal_to<int>());
-            BOOST_CHECK( pair_ccit.first == cref_cont1.end() );
-            BOOST_CHECK( pair_ccit.second == cref_cont2.end() );
+            eval_mismatch(cont1, cont2, cont1.end(), cont2.end());
+            eval_mismatch(cont1, cont2, std::equal_to<int>(), cont1.end(), cont2.end());
+            eval_mismatch(cref_cont1, cont2, cref_cont1.end(), cont2.end());
+            eval_mismatch(cref_cont1, cont2, std::equal_to<int>(), cref_cont1.end(), cont2.end());
+            eval_mismatch(cont1, cref_cont2, cont1.end(), cref_cont2.end());
+            eval_mismatch(cont1, cref_cont2, std::equal_to<int>(), cont1.end(), cref_cont2.end());
+            eval_mismatch(cref_cont1, cref_cont2, cref_cont1.end(), cref_cont2.end());
+            eval_mismatch(cref_cont1, cref_cont2, std::equal_to<int>(), cref_cont1.end(), cref_cont2.end());
 
             cont1.clear();
             cont2.clear();
             cont1 += 1,2,3,4;
             cont2 += 1,2,5,4;
-            pair_mmit = boost::mismatch(cont1, cont2);
-            BOOST_CHECK( pair_mmit.first != cont1.end() && *pair_mmit.first == 3 );
-            BOOST_CHECK( pair_mmit.second != cont2.end() && *pair_mmit.second == 5 );
-            pair_mmit = boost::mismatch(cont1, cont2, std::equal_to<int>());
-            BOOST_CHECK( pair_mmit.first != cont1.end() && *pair_mmit.first == 3 );
-            BOOST_CHECK( pair_mmit.second != cont2.end() && *pair_mmit.second == 5 );
-            pair_mmit = boost::mismatch(cont1, cont2, std::not_equal_to<int>());
-            BOOST_CHECK( pair_mmit.first == cont1.begin() );
-            BOOST_CHECK( pair_mmit.second == cont2.begin() );
-
-            pair_cmit = boost::mismatch(cref_cont1, cont2);
-            BOOST_CHECK( pair_cmit.first != cref_cont1.end() && *pair_cmit.first == 3 );
-            BOOST_CHECK( pair_cmit.second != cont2.end() && *pair_cmit.second == 5 );
-            pair_cmit = boost::mismatch(cref_cont1, cont2, std::equal_to<int>());
-            BOOST_CHECK( pair_cmit.first != cref_cont1.end() && *pair_cmit.first == 3 );
-            BOOST_CHECK( pair_cmit.second != cont2.end() && *pair_cmit.second == 5 );
-            pair_cmit = boost::mismatch(cref_cont1, cont2, std::not_equal_to<int>());
-            BOOST_CHECK( pair_cmit.first == cref_cont1.begin() );
-            BOOST_CHECK( pair_cmit.second == cont2.begin() );
-
-            pair_mcit = boost::mismatch(cont1, cref_cont2);
-            BOOST_CHECK( pair_mcit.first != cont1.end() && *pair_mcit.first == 3 );
-            BOOST_CHECK( pair_mcit.second != cref_cont2.end() && *pair_mcit.second == 5 );
-            pair_mcit = boost::mismatch(cont1, cref_cont2, std::equal_to<int>());
-            BOOST_CHECK( pair_mcit.first != cont1.end() && *pair_mcit.first == 3 );
-            BOOST_CHECK( pair_mcit.second != cref_cont2.end() && *pair_mcit.second == 5 );
-            pair_mcit = boost::mismatch(cont1, cref_cont2, std::not_equal_to<int>());
-            BOOST_CHECK( pair_mcit.first == cont1.begin() );
-            BOOST_CHECK( pair_mcit.second == cref_cont2.begin() );
-
-            pair_ccit = boost::mismatch(cref_cont1, cref_cont2);
-            BOOST_CHECK( pair_ccit.first != cref_cont1.end() && *pair_ccit.first == 3 );
-            BOOST_CHECK( pair_ccit.second != cref_cont2.end() && *pair_ccit.second == 5 );
-            pair_ccit = boost::mismatch(cref_cont1, cref_cont2, std::equal_to<int>());
-            BOOST_CHECK( pair_ccit.first != cref_cont1.end() && *pair_ccit.first == 3 );
-            BOOST_CHECK( pair_ccit.second != cref_cont2.end() && *pair_ccit.second == 5 );
-            pair_ccit = boost::mismatch(cref_cont1, cref_cont2, std::not_equal_to<int>());
-            BOOST_CHECK( pair_ccit.first == cref_cont1.begin() );
-            BOOST_CHECK( pair_ccit.second == cref_cont2.begin() );
+            eval_mismatch(cont1, cont2, 3, 5);
+            eval_mismatch(cont1, cont2, std::equal_to<int>(), 3, 5);
+            eval_mismatch(cont1, cont2, std::not_equal_to<int>(), cont1.begin(), cont2.begin());
+            eval_mismatch(cref_cont1, cont2, 3, 5);
+            eval_mismatch(cref_cont1, cont2, std::equal_to<int>(), 3, 5);
+            eval_mismatch(cref_cont1, cont2, std::not_equal_to<int>(), cref_cont1.begin(), cont2.begin());
+            eval_mismatch(cont1, cref_cont2, 3, 5);
+            eval_mismatch(cont1, cref_cont2, std::equal_to<int>(), 3, 5);
+            eval_mismatch(cont1, cref_cont2, std::not_equal_to<int>(), cont1.begin(), cref_cont2.begin());
+            eval_mismatch(cref_cont1, cref_cont2, 3, 5);
+            eval_mismatch(cref_cont1, cref_cont2, std::equal_to<int>(), 3, 5);
+            eval_mismatch(cref_cont1, cref_cont2, std::not_equal_to<int>(), cref_cont1.begin(), cref_cont2.begin());
         }
 
         void test_mismatch()
diff --git a/test/algorithm_test/next_permutation.cpp b/test/algorithm_test/next_permutation.cpp
index c2d782b..ee1c371 100644
--- a/test/algorithm_test/next_permutation.cpp
+++ b/test/algorithm_test/next_permutation.cpp
@@ -29,11 +29,19 @@ namespace boost
             const bool reference_ret
                 = std::next_permutation(reference.begin(), reference.end());
 
-            const bool test_ret
-                = boost::next_permutation(test);
+            const bool test_ret = boost::next_permutation(test);
 
             BOOST_CHECK( reference_ret == test_ret );
 
+            BOOST_CHECK_EQUAL_COLLECTIONS(
+                reference.begin(), reference.end(),
+                test.begin(), test.end()
+                );
+                
+            test = cont;
+            
+            BOOST_CHECK( test_ret == boost::next_permutation(boost::make_iterator_range(test)) );
+            
             BOOST_CHECK_EQUAL_COLLECTIONS(
                 reference.begin(), reference.end(),
                 test.begin(), test.end()
@@ -56,6 +64,15 @@ namespace boost
 
             BOOST_CHECK( reference_ret == test_ret );
 
+            BOOST_CHECK_EQUAL_COLLECTIONS(
+                reference.begin(), reference.end(),
+                test.begin(), test.end()
+                );
+                
+            test = cont;
+            
+            BOOST_CHECK( test_ret == boost::next_permutation(boost::make_iterator_range(test), pred) );
+            
             BOOST_CHECK_EQUAL_COLLECTIONS(
                 reference.begin(), reference.end(),
                 test.begin(), test.end()
diff --git a/test/algorithm_test/nth_element.cpp b/test/algorithm_test/nth_element.cpp
index dac2a2f..df241e9 100644
--- a/test/algorithm_test/nth_element.cpp
+++ b/test/algorithm_test/nth_element.cpp
@@ -29,7 +29,21 @@ namespace boost
             template<class Container, class Iterator>
             void test_nth_element(Container& cont, Iterator mid)
             {
+                const Container old_cont(cont);
+                
                 boost::nth_element(cont, mid);
+                
+                // Test the same operation on the container, for the
+                // case where a temporary is passed as the first
+                // argument.
+                Container cont2(old_cont);
+                const std::size_t index = std::distance(cont.begin(), mid);
+                Iterator mid2(cont2.begin());
+                std::advance(mid2, index);
+                boost::nth_element(boost::make_iterator_range(cont2), mid2);
+                
+                BOOST_CHECK_EQUAL_COLLECTIONS( cont.begin(), cont.end(),
+                                               cont2.begin(), cont2.end() );
             }
 
             template<class Container, class Iterator>
@@ -45,7 +59,19 @@ namespace boost
             template<class Container, class Iterator>
             void test_nth_element(Container& cont, Iterator mid)
             {
+                const Container old_cont(cont);
+                
                 boost::nth_element(cont, mid, BinaryPredicate());
+                
+                Container cont2(old_cont);
+                const std::size_t index = std::distance(cont.begin(), mid);
+                Iterator mid2(cont2.begin());
+                std::advance(mid2, index);
+                boost::nth_element(boost::make_iterator_range(cont2), mid2,
+                                   BinaryPredicate());
+                                   
+                BOOST_CHECK_EQUAL_COLLECTIONS( cont.begin(), cont.end(),
+                                               cont2.begin(), cont2.end() );
             }
 
             template<class Container, class Iterator>
diff --git a/test/algorithm_test/partial_sort.cpp b/test/algorithm_test/partial_sort.cpp
index 62ff64b..c13f7f1 100644
--- a/test/algorithm_test/partial_sort.cpp
+++ b/test/algorithm_test/partial_sort.cpp
@@ -31,7 +31,18 @@ namespace boost
             template<class Container, class Iterator>
             void test_partial_sort(Container& cont, Iterator mid)
             {
+                const Container old_cont(cont);
+                
                 boost::partial_sort(cont, mid);
+                
+                const std::size_t index = std::distance(cont.begin(), mid);
+                Container cont2(old_cont);
+                Iterator mid2(cont2.begin());
+                std::advance(mid2, index);
+                boost::partial_sort(cont2, mid2);
+                
+                BOOST_CHECK_EQUAL_COLLECTIONS( cont.begin(), cont.end(),
+                                               cont2.begin(), cont2.end() );
             }
 
             template<class Container, class Iterator>
@@ -47,7 +58,18 @@ namespace boost
             template<class Container, class Iterator>
             void test_partial_sort(Container& cont, Iterator mid)
             {
+                const Container old_cont(cont);
+                
                 boost::partial_sort(cont, mid, BinaryPredicate());
+                
+                const std::size_t index = std::distance(cont.begin(), mid);
+                Container cont2(old_cont);
+                Iterator mid2(cont2.begin());
+                std::advance(mid2, index);
+                boost::partial_sort(cont2, mid2, BinaryPredicate());
+                
+                BOOST_CHECK_EQUAL_COLLECTIONS( cont.begin(), cont.end(),
+                                               cont2.begin(), cont2.end() );
             }
 
             template<class Container, class Iterator>
diff --git a/test/algorithm_test/partition.cpp b/test/algorithm_test/partition.cpp
index 3f0ce61..fe136e0 100644
--- a/test/algorithm_test/partition.cpp
+++ b/test/algorithm_test/partition.cpp
@@ -41,7 +41,21 @@ namespace boost
             BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
             test_iter(Container& cont)
             {
-                return boost::partition(cont, UnaryPredicate());
+                typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iter_t;
+                
+                const Container old_cont(cont);
+                Container cont2(old_cont);
+                iter_t result = boost::partition(cont, UnaryPredicate());
+                
+                iter_t temp_result = boost::partition(cont2, UnaryPredicate());
+                cont2 = old_cont;
+                BOOST_CHECK( temp_result == boost::partition(
+                    boost::make_iterator_range(cont2), UnaryPredicate()) );
+                    
+                BOOST_CHECK_EQUAL_COLLECTIONS( cont.begin(), cont.end(),
+                                               cont2.begin(), cont2.end() );
+                                               
+                return result;
             }
 
             UnaryPredicate pred() const { return UnaryPredicate(); }
@@ -53,7 +67,22 @@ namespace boost
                 BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
                 operator()(Policy& policy, Container& cont)
                 {
-                    return boost::partition<return_type>(cont, policy.pred());
+                    typedef BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type result_t;
+                    
+                    const Container old_cont(cont);
+                    Container cont2(old_cont);
+                    result_t result = boost::partition<return_type>(cont, policy.pred());
+                    
+                    result_t temp_result = boost::partition<return_type>(
+                                                        cont2, policy.pred());
+                    cont2 = old_cont;
+                    BOOST_CHECK( temp_result == boost::partition<return_type>(
+                        boost::make_iterator_range(cont2), policy.pred()) );
+                        
+                    BOOST_CHECK_EQUAL_COLLECTIONS( cont.begin(), cont.end(),
+                                                   cont2.begin(), cont2.end() );
+                                                   
+                    return result;
                 }
             };
 
diff --git a/test/algorithm_test/prev_permutation.cpp b/test/algorithm_test/prev_permutation.cpp
index e1073c9..a4adc7b 100644
--- a/test/algorithm_test/prev_permutation.cpp
+++ b/test/algorithm_test/prev_permutation.cpp
@@ -25,12 +25,12 @@ namespace boost
         {
             Container reference(cont);
             Container test(cont);
+            Container test2(cont);
 
             const bool reference_ret
                 = std::prev_permutation(reference.begin(), reference.end());
 
-            const bool test_ret
-                = boost::prev_permutation(test);
+            const bool test_ret = boost::prev_permutation(test);
 
             BOOST_CHECK( reference_ret == test_ret );
 
@@ -38,6 +38,14 @@ namespace boost
                 reference.begin(), reference.end(),
                 test.begin(), test.end()
                 );
+
+            BOOST_CHECK( test_ret == boost::prev_permutation(
+                                boost::make_iterator_range(test2)) );
+                                
+            BOOST_CHECK_EQUAL_COLLECTIONS(
+                reference.begin(), reference.end(),
+                test2.begin(), test2.end()
+                );
         }
 
         template<class Container, class BinaryPredicate>
@@ -46,13 +54,13 @@ namespace boost
         {
             Container reference(cont);
             Container test(cont);
+            Container test2(cont);
 
             const bool reference_ret
                 = std::prev_permutation(reference.begin(), reference.end(),
                                         pred);
 
-            const bool test_ret
-                = boost::prev_permutation(test, pred);
+            const bool test_ret = boost::prev_permutation(test, pred);
 
             BOOST_CHECK( reference_ret == test_ret );
 
@@ -60,6 +68,14 @@ namespace boost
                 reference.begin(), reference.end(),
                 test.begin(), test.end()
                 );
+                
+            BOOST_CHECK( test_ret == boost::prev_permutation(
+                boost::make_iterator_range(test2), pred) );
+                
+            BOOST_CHECK_EQUAL_COLLECTIONS(
+                reference.begin(), reference.end(),
+                test2.begin(), test2.end()
+                );
         }
 
         template<class Container>
diff --git a/test/algorithm_test/random_shuffle.cpp b/test/algorithm_test/random_shuffle.cpp
index ba55f51..410749a 100644
--- a/test/algorithm_test/random_shuffle.cpp
+++ b/test/algorithm_test/random_shuffle.cpp
@@ -110,6 +110,14 @@ namespace boost
                 {
                     shuffled = true;
                 }
+                
+                // Verify that the shuffle can be performed on a
+                // temporary range
+                Container test2(cont);
+                boost::random_shuffle(boost::make_iterator_range(test2));
+                ok = test_shuffle_result(cont, test2);
+                if (!ok)
+                    break;
             }
         }
 
@@ -124,6 +132,17 @@ namespace boost
             {
                 BOOST_CHECK( gen.invocation_count() > 0 );
             }
+            
+            // Test that random shuffle works when 
+            // passed a temporary range
+            RandomGenerator gen2;
+            Container cont2(old_cont);
+            boost::random_shuffle(boost::make_iterator_range(cont2), gen2);
+            test_shuffle_result(cont2, old_cont);
+            if (cont2.size() > 2)
+            {
+                BOOST_CHECK( gen2.invocation_count() > 0 );
+            }
         }
 
         template<class Container>
diff --git a/test/algorithm_test/remove.cpp b/test/algorithm_test/remove.cpp
index 46e6591..3e4ab16 100644
--- a/test/algorithm_test/remove.cpp
+++ b/test/algorithm_test/remove.cpp
@@ -43,7 +43,16 @@ namespace boost
                                std::distance(reference.begin(), reference_it) );
 
             BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-                test.begin(), test.end() );
+                                           test.begin(), test.end() );
+                                           
+            Container test2(c);
+            iterator_t test_it2 = boost::remove(test2, to_remove);
+            
+            BOOST_CHECK_EQUAL( std::distance(test2.begin(), test_it2),
+                               std::distance(reference.begin(), reference_it) );
+                               
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           test2.begin(), test2.end() );
         }
 
         template< class Container >
diff --git a/test/algorithm_test/remove_copy.cpp b/test/algorithm_test/remove_copy.cpp
index 43d0ebe..4050ef4 100644
--- a/test/algorithm_test/remove_copy.cpp
+++ b/test/algorithm_test/remove_copy.cpp
@@ -50,6 +50,15 @@ namespace
 
         BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
             test.begin(), test.end() );
+            
+        std::vector<value_type> test2;
+        test_append(
+            boost::remove_copy(boost::make_iterator_range(c),
+                               std::back_inserter(test2), to_remove),
+            to_remove);
+                               
+        BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                       test2.begin(), test2.end() );
     }
 
     template< class Container >
diff --git a/test/algorithm_test/remove_copy_if.cpp b/test/algorithm_test/remove_copy_if.cpp
index 0418ddd..c269c2a 100644
--- a/test/algorithm_test/remove_copy_if.cpp
+++ b/test/algorithm_test/remove_copy_if.cpp
@@ -48,7 +48,17 @@ namespace
             );
 
         BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-            test.begin(), test.end() );
+                                       test.begin(), test.end() );
+                                       
+        std::vector<value_type> test2;
+        test_append(
+            boost::remove_copy_if(boost::make_iterator_range(c),
+                                  std::back_inserter(test2), pred),
+            value_type()
+            );
+            
+        BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                       test2.begin(), test2.end() );
     }
 
     template< class Container >
diff --git a/test/algorithm_test/remove_if.cpp b/test/algorithm_test/remove_if.cpp
index 1e77e7b..58fc07f 100644
--- a/test/algorithm_test/remove_if.cpp
+++ b/test/algorithm_test/remove_if.cpp
@@ -43,7 +43,17 @@ namespace boost
                                std::distance(reference.begin(), reference_it) );
 
             BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-                test.begin(), test.end() );
+                                           test.begin(), test.end() );
+                
+            Container test2(c);
+            iterator_t test_it2 = boost::remove_if(
+                boost::make_iterator_range(test2), pred);
+                
+            BOOST_CHECK_EQUAL( std::distance(test2.begin(), test_it2),
+                               std::distance(reference.begin(), reference_it) );
+                               
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           test2.begin(), test2.end() );
         }
 
         template< class Container >
diff --git a/test/algorithm_test/replace.cpp b/test/algorithm_test/replace.cpp
index 4a882dc..356024f 100644
--- a/test/algorithm_test/replace.cpp
+++ b/test/algorithm_test/replace.cpp
@@ -36,7 +36,14 @@ namespace boost
             boost::replace(target, what, with_what);
 
             BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-                target.begin(), target.end() );
+                                           target.begin(), target.end() );
+                
+            std::vector<int> target2(cont.begin(), cont.end());
+            boost::replace(boost::make_iterator_range(target2), what,
+                           with_what);
+                           
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           target2.begin(), target2.end() );
 
         }
 
diff --git a/test/algorithm_test/replace_copy.cpp b/test/algorithm_test/replace_copy.cpp
index a2ce612..6ae12e2 100644
--- a/test/algorithm_test/replace_copy.cpp
+++ b/test/algorithm_test/replace_copy.cpp
@@ -51,7 +51,17 @@ namespace
             to_replace);
 
         BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-            test.begin(), test.end() );
+                                       test.begin(), test.end() );
+            
+        std::vector<value_type> test2;
+        test_append(
+            boost::replace_copy(boost::make_iterator_range(c),
+                                std::back_inserter(test2), to_replace,
+                                replace_with),
+            to_replace);
+            
+        BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                       test2.begin(), test2.end() );
     }
 
     template< class Container >
diff --git a/test/algorithm_test/replace_copy_if.cpp b/test/algorithm_test/replace_copy_if.cpp
index 5a68fe4..6873547 100644
--- a/test/algorithm_test/replace_copy_if.cpp
+++ b/test/algorithm_test/replace_copy_if.cpp
@@ -49,7 +49,18 @@ namespace
             );
 
         BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-            test.begin(), test.end() );
+                                       test.begin(), test.end() );
+            
+        std::vector<value_type> test2;
+        test_append(
+            boost::replace_copy_if(boost::make_iterator_range(c),
+                                   std::back_inserter(test2), pred,
+                                   replace_with),
+            value_type()
+            );
+            
+        BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                       test2.begin(), test2.end() );
     }
 
     template< class Container >
diff --git a/test/algorithm_test/replace_if.cpp b/test/algorithm_test/replace_if.cpp
index e1dd26f..12d7293 100644
--- a/test/algorithm_test/replace_if.cpp
+++ b/test/algorithm_test/replace_if.cpp
@@ -40,8 +40,14 @@ namespace boost
             boost::replace_if(target, boost::bind(pred, _1, what), with_what);
 
             BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-                target.begin(), target.end() );
-
+                                           target.begin(), target.end() );
+                
+            std::vector<int> target2(cont.begin(), cont.end());
+            boost::replace_if(boost::make_iterator_range(target2),
+                              boost::bind(pred, _1, what), with_what);
+                              
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           target2.begin(), target2.end() );
         }
 
         template< class Container >
diff --git a/test/algorithm_test/reverse.cpp b/test/algorithm_test/reverse.cpp
index 611a464..3ad63cb 100644
--- a/test/algorithm_test/reverse.cpp
+++ b/test/algorithm_test/reverse.cpp
@@ -29,14 +29,16 @@ namespace boost
         {
             Container reference(cont);
             Container test(cont);
+            Container test2(cont);
 
             boost::reverse(test);
             std::reverse(reference.begin(), reference.end());
-
-            BOOST_CHECK_EQUAL_COLLECTIONS(
-                reference.begin(), reference.end(),
-                test.begin(), test.end()
-                );
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           test.begin(), test.end() );
+                                           
+            boost::reverse(boost::make_iterator_range(test2));
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           test2.begin(), test2.end() );
         }
 
         template<class Container>
diff --git a/test/algorithm_test/reverse_copy.cpp b/test/algorithm_test/reverse_copy.cpp
index 8a7d931..92ef485 100644
--- a/test/algorithm_test/reverse_copy.cpp
+++ b/test/algorithm_test/reverse_copy.cpp
@@ -45,10 +45,19 @@ namespace
             value_type()
             );
 
-        BOOST_CHECK_EQUAL_COLLECTIONS(
-            reference.begin(), reference.end(),
-            test.begin(), test.end()
+        BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                       test.begin(), test.end() );
+            
+        test.clear();
+        
+        test_append(
+            boost::reverse_copy(boost::make_iterator_range(cont),
+                                std::back_inserter(test)),
+            value_type()
             );
+            
+        BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                       test.begin(), test.end() );
     }
 
     template<class Container>
diff --git a/test/algorithm_test/rotate.cpp b/test/algorithm_test/rotate.cpp
index f8b394a..b6b7af2 100644
--- a/test/algorithm_test/rotate.cpp
+++ b/test/algorithm_test/rotate.cpp
@@ -42,10 +42,18 @@ namespace boost
 
             boost::rotate(test, test_where_it);
 
-            BOOST_CHECK_EQUAL_COLLECTIONS(
-                reference.begin(), reference.end(),
-                test.begin(), test.end()
-                );
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           test.begin(), test.end() );
+                
+            test = cont;
+            test_where_it = test.begin();
+            std::advance(test_where_it,
+                         std::distance(cont.begin(), where_it));
+                         
+            boost::rotate(boost::make_iterator_range(test), test_where_it);
+            
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           test.begin(), test.end() );
         }
 
         template<class Container>
diff --git a/test/algorithm_test/rotate_copy.cpp b/test/algorithm_test/rotate_copy.cpp
index c403442..5615479 100644
--- a/test/algorithm_test/rotate_copy.cpp
+++ b/test/algorithm_test/rotate_copy.cpp
@@ -48,10 +48,19 @@ namespace
             value_type()
             );
 
-        BOOST_CHECK_EQUAL_COLLECTIONS(
-            reference.begin(), reference.end(),
-            test.begin(), test.end()
+        BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                       test.begin(), test.end() );
+            
+        test.clear();
+        
+        test_append(
+            boost::rotate_copy(boost::make_iterator_range(cont), where_it,
+                               std::back_inserter(test)),
+            value_type()
             );
+            
+        BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                       test.begin(), test.end() );
     }
 
     template<class Container>
diff --git a/test/algorithm_test/search.cpp b/test/algorithm_test/search.cpp
index 460f70d..91f19bd 100644
--- a/test/algorithm_test/search.cpp
+++ b/test/algorithm_test/search.cpp
@@ -33,9 +33,25 @@ namespace boost
             const Container2& ccont2 = cont2;
 
             iterator1_t it = boost::search(cont1, cont2);
+            BOOST_CHECK( it == boost::search(boost::make_iterator_range(cont1), cont2) );
+            BOOST_CHECK( it == boost::search(cont1, boost::make_iterator_range(cont2)) );
+            BOOST_CHECK( it == boost::search(boost::make_iterator_range(cont1),
+                                             boost::make_iterator_range(cont2)) );
             iterator1_t it2 = boost::search(cont1, ccont2);
+            BOOST_CHECK( it2 == boost::search(boost::make_iterator_range(cont1), ccont2) );
+            BOOST_CHECK( it2 == boost::search(cont1, boost::make_iterator_range(ccont2)) );
+            BOOST_CHECK( it2 == boost::search(boost::make_iterator_range(cont1),
+                                              boost::make_iterator_range(ccont2)) );
             const_iterator1_t cit = boost::search(ccont1, cont2);
+            BOOST_CHECK( cit == boost::search(boost::make_iterator_range(ccont1), cont2) );
+            BOOST_CHECK( cit == boost::search(ccont1, boost::make_iterator_range(cont2)) );
+            BOOST_CHECK( cit == boost::search(boost::make_iterator_range(ccont1),
+                                              boost::make_iterator_range(cont2)) );
             const_iterator1_t cit2 = boost::search(ccont1, ccont2);
+            BOOST_CHECK( cit2 == boost::search(boost::make_iterator_range(ccont1), ccont2) );
+            BOOST_CHECK( cit2 == boost::search(ccont1, boost::make_iterator_range(ccont2)) );
+            BOOST_CHECK( cit2 == boost::search(boost::make_iterator_range(ccont1),
+                                               boost::make_iterator_range(ccont2)) );
 
             BOOST_CHECK( it == std::search(cont1.begin(), cont1.end(), cont2.begin(), cont2.end()) );
             BOOST_CHECK( it2 == std::search(cont1.begin(), cont1.end(), ccont2.begin(), ccont2.end()) );
diff --git a/test/algorithm_test/search_n.cpp b/test/algorithm_test/search_n.cpp
index d419f9c..3b0aa91 100644
--- a/test/algorithm_test/search_n.cpp
+++ b/test/algorithm_test/search_n.cpp
@@ -32,14 +32,12 @@ namespace
         for (std::size_t n = 0; n < cont1.size(); ++n)
         {
             iterator1_t it = boost::search_n(cont1, n, value);
-            iterator1_t it2 = boost::search_n(cont1, n, value);
-            const_iterator1_t cit = boost::search_n(ccont1, n, value);
-            const_iterator1_t cit2 = boost::search_n(ccont1, n, value);
-
+            BOOST_CHECK( it == boost::search_n(boost::make_iterator_range(cont1), n, value) );
             BOOST_CHECK( it == std::search_n(cont1.begin(), cont1.end(), n, value) );
-            BOOST_CHECK( it2 == std::search_n(cont1.begin(), cont1.end(), n, value) );
+
+            const_iterator1_t cit = boost::search_n(ccont1, n, value);
+            BOOST_CHECK( cit == boost::search_n(boost::make_iterator_range(ccont1), n, value) );
             BOOST_CHECK( cit == std::search_n(ccont1.begin(), ccont1.end(), n, value) );
-            BOOST_CHECK( cit2 == std::search_n(ccont1.begin(), ccont1.end(), n, value) );
         }
     }
 
diff --git a/test/algorithm_test/set_difference.cpp b/test/algorithm_test/set_difference.cpp
index 7fb0974..84dc62c 100644
--- a/test/algorithm_test/set_difference.cpp
+++ b/test/algorithm_test/set_difference.cpp
@@ -62,6 +62,28 @@ namespace boost
 
             check_result(reference, reference_result,
                          test_cont, test_result);
+                         
+            test_result = boost::set_difference(
+                            boost::make_iterator_range(cont1), cont2,
+                            test_cont.begin());
+            
+            check_result(reference, reference_result,
+                         test_cont, test_result);
+                         
+            test_result = boost::set_difference(
+                            cont1, boost::make_iterator_range(cont2),
+                            test_cont.begin());
+                            
+            check_result(reference, reference_result,
+                         test_cont, test_result);
+                         
+            test_result = boost::set_difference(
+                            boost::make_iterator_range(cont1),
+                            boost::make_iterator_range(cont2),
+                            test_cont.begin());
+                            
+            check_result(reference, reference_result,
+                         test_cont, test_result);
         }
 
         template<class Container, class BinaryPredicate>
@@ -100,6 +122,28 @@ namespace boost
 
             check_result(reference, reference_result,
                          test_cont, test_result);
+                         
+            test_result = boost::set_difference(
+                            boost::make_iterator_range(cont1), cont2,
+                            test_cont.begin(), pred);
+                            
+            check_result(reference, reference_result,
+                         test_cont, test_result);
+                         
+            test_result = boost::set_difference(
+                            cont1, boost::make_iterator_range(cont2),
+                            test_cont.begin(), pred);
+                            
+            check_result(reference, reference_result,
+                         test_cont, test_result);
+                         
+            test_result = boost::set_difference(
+                            boost::make_iterator_range(cont1),
+                            boost::make_iterator_range(cont2),
+                            test_cont.begin(), pred);
+                            
+            check_result(reference, reference_result,
+                         test_cont, test_result);
         }
 
         template<class Container1, class Container2>
diff --git a/test/algorithm_test/set_intersection.cpp b/test/algorithm_test/set_intersection.cpp
index 5e2ce1b..213bbdf 100644
--- a/test/algorithm_test/set_intersection.cpp
+++ b/test/algorithm_test/set_intersection.cpp
@@ -62,6 +62,28 @@ namespace boost
 
             check_result(reference, reference_result,
                          test_cont, test_result);
+                         
+            test_result = boost::set_intersection(
+                            boost::make_iterator_range(cont1), cont2,
+                            test_cont.begin());
+                            
+            check_result(reference, reference_result,
+                         test_cont, test_result);
+                         
+            test_result = boost::set_intersection(
+                            cont1, boost::make_iterator_range(cont2),
+                            test_cont.begin());
+                            
+            check_result(reference, reference_result,
+                         test_cont, test_result);
+                         
+            test_result = boost::set_intersection(
+                            boost::make_iterator_range(cont1),
+                            boost::make_iterator_range(cont2),
+                            test_cont.begin());
+                            
+            check_result(reference, reference_result,
+                         test_cont, test_result);
         }
 
         template<class Container, class BinaryPredicate>
@@ -100,6 +122,28 @@ namespace boost
 
             check_result(reference, reference_result,
                          test_cont, test_result);
+                         
+            test_result = boost::set_intersection(
+                            boost::make_iterator_range(cont1), cont2,
+                            test_cont.begin(), pred);
+                            
+            check_result(reference, reference_result,
+                         test_cont, test_result);
+                         
+            test_result = boost::set_intersection(
+                            cont1, boost::make_iterator_range(cont2),
+                            test_cont.begin(), pred);
+                            
+            check_result(reference, reference_result,
+                         test_cont, test_result);
+                         
+            test_result = boost::set_intersection(
+                            boost::make_iterator_range(cont1),
+                            boost::make_iterator_range(cont2),
+                            test_cont.begin(), pred);
+                            
+            check_result(reference, reference_result,
+                         test_cont, test_result);
         }
 
         template<class Container1, class Container2>
diff --git a/test/algorithm_test/set_symmetric_difference.cpp b/test/algorithm_test/set_symmetric_difference.cpp
index 149532c..b792fd8 100644
--- a/test/algorithm_test/set_symmetric_difference.cpp
+++ b/test/algorithm_test/set_symmetric_difference.cpp
@@ -63,6 +63,28 @@ namespace boost
 
             check_result(reference, reference_result,
                          test_cont, test_result);
+                         
+            test_result = boost::set_symmetric_difference(
+                            boost::make_iterator_range(cont1), cont2,
+                            test_cont.begin());
+                            
+            check_result(reference, reference_result,
+                         test_cont, test_result);
+                         
+            test_result = boost::set_symmetric_difference(
+                            cont1, boost::make_iterator_range(cont2),
+                            test_cont.begin());
+                            
+            check_result(reference, reference_result,
+                         test_cont, test_result);
+                         
+            test_result = boost::set_symmetric_difference(
+                            boost::make_iterator_range(cont1),
+                            boost::make_iterator_range(cont2),
+                            test_cont.begin());
+                            
+            check_result(reference, reference_result,
+                         test_cont, test_result);
         }
 
         template<class Container, class BinaryPredicate>
@@ -102,6 +124,28 @@ namespace boost
 
             check_result(reference, reference_result,
                          test_cont, test_result);
+                         
+            test_result = boost::set_symmetric_difference(
+                            boost::make_iterator_range(cont1), cont2,
+                            test_cont.begin(), pred);
+                            
+            check_result(reference, reference_result,
+                         test_cont, test_result);
+                         
+            test_result = boost::set_symmetric_difference(
+                            cont1, boost::make_iterator_range(cont2),
+                            test_cont.begin(), pred);
+                            
+            check_result(reference, reference_result,
+                         test_cont, test_result);
+                         
+            test_result = boost::set_symmetric_difference(
+                            boost::make_iterator_range(cont1),
+                            boost::make_iterator_range(cont2),
+                            test_cont.begin(), pred);
+                            
+            check_result(reference, reference_result,
+                         test_cont, test_result);
         }
 
         template<class Container1, class Container2>
diff --git a/test/algorithm_test/set_union.cpp b/test/algorithm_test/set_union.cpp
index f9450b3..7f9f10a 100644
--- a/test/algorithm_test/set_union.cpp
+++ b/test/algorithm_test/set_union.cpp
@@ -62,6 +62,26 @@ namespace boost
 
             check_result(reference, reference_result,
                          test_cont, test_result);
+                         
+            test_result = boost::set_union(boost::make_iterator_range(cont1),
+                                           cont2, test_cont.begin());
+                                           
+            check_result(reference, reference_result,
+                         test_cont, test_result);
+                         
+            test_result = boost::set_union(cont1,
+                                           boost::make_iterator_range(cont2),
+                                           test_cont.begin());
+                                           
+            check_result(reference, reference_result,
+                         test_cont, test_result);
+                         
+            test_result = boost::set_union(boost::make_iterator_range(cont1),
+                                           boost::make_iterator_range(cont2),
+                                           test_cont.begin());
+                                           
+            check_result(reference, reference_result,
+                         test_cont, test_result);
         }
 
         template<class Container, class BinaryPredicate>
@@ -100,6 +120,26 @@ namespace boost
 
             check_result(reference, reference_result,
                          test_cont, test_result);
+                         
+            test_result = boost::set_union(boost::make_iterator_range(cont1),
+                                           cont2, test_cont.begin(), pred);
+                                           
+            check_result(reference, reference_result,
+                         test_cont, test_result);
+                         
+            test_result = boost::set_union(cont1,
+                                           boost::make_iterator_range(cont2),
+                                           test_cont.begin(), pred);
+                                           
+            check_result(reference, reference_result,
+                         test_cont, test_result);
+                         
+            test_result = boost::set_union(boost::make_iterator_range(cont1),
+                                           boost::make_iterator_range(cont2),
+                                           test_cont.begin(), pred);
+                                           
+            check_result(reference, reference_result,
+                         test_cont, test_result);
         }
 
         template<class Container1, class Container2>
diff --git a/test/algorithm_test/sort.cpp b/test/algorithm_test/sort.cpp
index b1b26e7..c6611f7 100644
--- a/test/algorithm_test/sort.cpp
+++ b/test/algorithm_test/sort.cpp
@@ -33,10 +33,13 @@ namespace boost
             boost::sort(test);
             std::sort(reference.begin(), reference.end());
 
-            BOOST_CHECK_EQUAL_COLLECTIONS(
-                reference.begin(), reference.end(),
-                test.begin(), test.end()
-                );
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           test.begin(), test.end() );
+                                           
+            Container test2(cont);
+            boost::sort(boost::make_iterator_range(test2));
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           test2.begin(), test2.end() );
         }
 
         template<class Container, class BinaryPredicate>
@@ -52,6 +55,11 @@ namespace boost
                 reference.begin(), reference.end(),
                 test.begin(), test.end()
                 );
+                
+            Container test2(cont);
+            boost::sort(boost::make_iterator_range(test2), pred);
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           test2.begin(), test2.end() );
         }
 
         template<class Container>
diff --git a/test/algorithm_test/stable_partition.cpp b/test/algorithm_test/stable_partition.cpp
index fad4bef..5f55b7d 100644
--- a/test/algorithm_test/stable_partition.cpp
+++ b/test/algorithm_test/stable_partition.cpp
@@ -41,7 +41,21 @@ namespace boost
             BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
             test_iter(Container& cont)
             {
-                return boost::stable_partition(cont, UnaryPredicate());
+                Container cont2(cont);
+                
+                typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iter_t;
+                iter_t result = boost::stable_partition(cont, UnaryPredicate());
+                
+                iter_t temp_result = boost::stable_partition(
+                    boost::make_iterator_range(cont2), UnaryPredicate());
+                    
+                BOOST_CHECK_EQUAL( std::distance(cont.begin(), result),
+                                   std::distance(cont2.begin(), temp_result) );
+                                   
+                BOOST_CHECK_EQUAL_COLLECTIONS( cont.begin(), cont.end(),
+                                               cont2.begin(), cont2.end() );
+                
+                return result;
             }
 
             UnaryPredicate pred() const { return UnaryPredicate(); }
@@ -53,7 +67,17 @@ namespace boost
                 BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
                 operator()(Policy& policy, Container& cont)
                 {
-                    return boost::stable_partition<return_type>(cont, policy.pred());
+                    typedef BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type result_t;
+                    Container cont2(cont);
+                    result_t result = boost::stable_partition<return_type>(cont, policy.pred());
+                    
+                    result_t result2 = boost::stable_partition<return_type>(
+                                        boost::make_iterator_range(cont2), policy.pred());
+                                        
+                    BOOST_CHECK_EQUAL_COLLECTIONS( cont2.begin(), cont2.end(),
+                                                   cont.begin(), cont.end() );
+                                        
+                    return result;
                 }
             };
 
diff --git a/test/algorithm_test/stable_sort.cpp b/test/algorithm_test/stable_sort.cpp
index eb5518c..8372bd6 100644
--- a/test/algorithm_test/stable_sort.cpp
+++ b/test/algorithm_test/stable_sort.cpp
@@ -33,10 +33,13 @@ namespace boost
             boost::stable_sort(test);
             std::stable_sort(reference.begin(), reference.end());
 
-            BOOST_CHECK_EQUAL_COLLECTIONS(
-                reference.begin(), reference.end(),
-                test.begin(), test.end()
-                );
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           test.begin(), test.end() );
+                
+            test = cont;
+            boost::stable_sort(boost::make_iterator_range(test));
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           test.begin(), test.end() );
         }
 
         template<class Container, class BinaryPredicate>
@@ -48,10 +51,13 @@ namespace boost
             boost::stable_sort(test, pred);
             std::stable_sort(reference.begin(), reference.end(), pred);
 
-            BOOST_CHECK_EQUAL_COLLECTIONS(
-                reference.begin(), reference.end(),
-                test.begin(), test.end()
-                );
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           test.begin(), test.end() );
+                                           
+            test = cont;
+            boost::stable_sort(boost::make_iterator_range(test), pred);
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           test.begin(), test.end() );
         }
 
         template<class Container>
diff --git a/test/algorithm_test/swap_ranges.cpp b/test/algorithm_test/swap_ranges.cpp
index b50431c..a96bfac 100644
--- a/test/algorithm_test/swap_ranges.cpp
+++ b/test/algorithm_test/swap_ranges.cpp
@@ -35,15 +35,36 @@ namespace
         Container2 test2(source2);
         boost::swap_ranges(test1, test2);
 
-        BOOST_CHECK_EQUAL_COLLECTIONS(
-            reference1.begin(), reference1.end(),
-            test1.begin(), test1.end()
-            );
+        BOOST_CHECK_EQUAL_COLLECTIONS( reference1.begin(), reference1.end(),
+                                       test1.begin(), test1.end() );
 
-        BOOST_CHECK_EQUAL_COLLECTIONS(
-            reference2.begin(), reference2.end(),
-            test2.begin(), test2.end()
-            );
+        BOOST_CHECK_EQUAL_COLLECTIONS( reference2.begin(), reference2.end(),
+                                       test2.begin(), test2.end() );
+                                       
+        test1 = source1;
+        test2 = source2;
+        boost::swap_ranges(boost::make_iterator_range(test1), test2);
+        BOOST_CHECK_EQUAL_COLLECTIONS( reference1.begin(), reference1.end(),
+                                       test1.begin(), test1.end() );
+        BOOST_CHECK_EQUAL_COLLECTIONS( reference2.begin(), reference2.end(),
+                                       test2.begin(), test2.end() );
+                                       
+        test1 = source1;
+        test2 = source2;
+        boost::swap_ranges(test1, boost::make_iterator_range(test2));
+        BOOST_CHECK_EQUAL_COLLECTIONS( reference1.begin(), reference1.end(),
+                                       test1.begin(), test1.end() );
+        BOOST_CHECK_EQUAL_COLLECTIONS( reference2.begin(), reference2.end(),
+                                       test2.begin(), test2.end() );
+                                       
+        test1 = source1;
+        test2 = source2;
+        boost::swap_ranges(boost::make_iterator_range(test1),
+                           boost::make_iterator_range(test2));
+        BOOST_CHECK_EQUAL_COLLECTIONS( reference1.begin(), reference1.end(),
+                                       test1.begin(), test1.end() );
+        BOOST_CHECK_EQUAL_COLLECTIONS( reference2.begin(), reference2.end(),
+                                       test2.begin(), test2.end() );
     }
 
     template<class Container1, class Container2>
diff --git a/test/algorithm_test/transform.cpp b/test/algorithm_test/transform.cpp
index 7f016a2..3e37180 100644
--- a/test/algorithm_test/transform.cpp
+++ b/test/algorithm_test/transform.cpp
@@ -47,16 +47,23 @@ namespace boost
 
             BOOST_CHECK( test_it == target.end() );
             BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-                target.begin(), target.end() );
-
+                                           target.begin(), target.end() );
+                
+            BOOST_CHECK( test_it == boost::transform(boost::make_iterator_range(cont), target.begin(), fn) );
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           target.begin(), target.end() );
+                                           
             target.clear();
             target.resize(ccont.size());
 
             test_it = boost::transform(ccont, target.begin(), fn);
-
+            
             BOOST_CHECK( test_it == target.end() );
             BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-                target.begin(), target.end() );
+                                           target.begin(), target.end() );
+            BOOST_CHECK( test_it == boost::transform(boost::make_iterator_range(ccont), target.begin(), fn) );
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           target.begin(), target.end() );
         }
 
         template< class Container >
@@ -97,10 +104,25 @@ namespace boost
 
             iterator_t test_it
                 = boost::transform(cont1, cont2, target.begin(), fn);
-
+                
             BOOST_CHECK( test_it == target.end() );
             BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-                target.begin(), target.end() );
+                                           target.begin(), target.end() );
+                                           
+            BOOST_CHECK( test_it == boost::transform(boost::make_iterator_range(cont1), cont2, target.begin(), fn) );
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           target.begin(), target.end() );
+                                           
+            BOOST_CHECK( test_it == boost::transform(cont1, boost::make_iterator_range(cont2), target.begin(), fn) );
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           target.begin(), target.end() );
+                                           
+            BOOST_CHECK( test_it == boost::transform(boost::make_iterator_range(cont1),
+                                                     boost::make_iterator_range(cont2),
+                                                     target.begin(), fn) );
+            BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+                                           target.begin(), target.end() );
+                         
 
             target.clear();
             target.resize(ccont1.size());
diff --git a/test/algorithm_test/unique.cpp b/test/algorithm_test/unique.cpp
index 2e2ebfa..49af0e3 100644
--- a/test/algorithm_test/unique.cpp
+++ b/test/algorithm_test/unique.cpp
@@ -47,7 +47,18 @@ namespace boost
                 BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
                 operator()(Policy&, Container& cont)
                 {
-                    return boost::unique<return_type>(cont);
+                    typedef BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type result_t;
+                    
+                    Container cont2(cont);
+                    
+                    result_t result = boost::unique<return_type>(cont);
+                    
+                    boost::unique<return_type>(boost::make_iterator_range(cont2));
+                    
+                    BOOST_CHECK_EQUAL_COLLECTIONS( cont.begin(), cont.end(),
+                                                   cont2.begin(), cont2.end() );
+                    
+                    return result;
                 }
             };
 
@@ -82,7 +93,18 @@ namespace boost
                 BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type
                 operator()(Policy& policy, Container& cont)
                 {
-                    return boost::unique<return_type>(cont, policy.pred());
+                    typedef BOOST_DEDUCED_TYPENAME range_return<Container,return_type>::type result_t;
+                    
+                    Container cont2(cont);
+                    
+                    result_t result = boost::unique<return_type>(cont, policy.pred());
+                    
+                    boost::unique<return_type>(boost::make_iterator_range(cont2), policy.pred());
+                    
+                    BOOST_CHECK_EQUAL_COLLECTIONS( cont.begin(), cont.end(),
+                                                   cont2.begin(), cont2.end() );
+                    
+                    return result;
                 }
             };
 
diff --git a/test/algorithm_test/unique_copy.cpp b/test/algorithm_test/unique_copy.cpp
index f3a3296..21f107a 100644
--- a/test/algorithm_test/unique_copy.cpp
+++ b/test/algorithm_test/unique_copy.cpp
@@ -49,6 +49,17 @@ namespace
 
         BOOST_CHECK_EQUAL_COLLECTIONS(reference.begin(), reference.end(),
                                       test.begin(), test.end());
+                                      
+        test.clear();
+        
+        test_append(
+            boost::unique_copy(boost::make_iterator_range(c),
+                               std::back_inserter(test)),
+            value_type()
+            );
+            
+        BOOST_CHECK_EQUAL_COLLECTIONS(reference.begin(), reference.end(),
+                                      test.begin(), test.end());
     }
 
     template<class Container, class Pred>
@@ -70,6 +81,17 @@ namespace
 
         BOOST_CHECK_EQUAL_COLLECTIONS(reference.begin(), reference.end(),
                                       test.begin(), test.end());
+                                      
+        test.clear();
+        
+        test_append(
+            boost::unique_copy(boost::make_iterator_range(c),
+                               std::back_inserter(test), pred),
+            value_type()
+            );
+            
+        BOOST_CHECK_EQUAL_COLLECTIONS(reference.begin(), reference.end(),
+                                      test.begin(), test.end());
     }
 
     template<class Container, class Pred>
diff --git a/test/algorithm_test/upper_bound.cpp b/test/algorithm_test/upper_bound.cpp
index 2eb64cf..95e3965 100644
--- a/test/algorithm_test/upper_bound.cpp
+++ b/test/algorithm_test/upper_bound.cpp
@@ -32,7 +32,10 @@ namespace boost
             BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
             test_iter(Container& cont)
             {
-                return boost::upper_bound(cont, 5);
+                typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iter_t;
+                iter_t result = boost::upper_bound(cont, 5);
+                BOOST_CHECK( result == boost::upper_bound(boost::make_iterator_range(cont), 5) );
+                return result;
             }
 
             template<range_return_value result_type>
@@ -42,7 +45,10 @@ namespace boost
                 BOOST_DEDUCED_TYPENAME range_return<Container,result_type>::type
                 operator()(Policy&, Container& cont)
                 {
-                    return boost::upper_bound<result_type>(cont, 5);
+                    typedef BOOST_DEDUCED_TYPENAME range_return<Container,result_type>::type result_t;
+                    result_t result = boost::upper_bound<result_type>(cont, 5);
+                    BOOST_CHECK( result == boost::upper_bound<result_type>(boost::make_iterator_range(cont), 5) );
+                    return result;
                 }
             };
 
@@ -61,7 +67,10 @@ namespace boost
             BOOST_DEDUCED_TYPENAME range_iterator<Container>::type
             test_iter(Container& cont)
             {
-                return boost::upper_bound(cont, 5, BinaryPredicate());
+                typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iter_t;
+                iter_t result = boost::upper_bound(cont, 5, BinaryPredicate());
+                BOOST_CHECK( result == boost::upper_bound(boost::make_iterator_range(cont), 5, BinaryPredicate()) );
+                return result;
             }
 
             template< range_return_value result_type>
@@ -71,8 +80,14 @@ namespace boost
                 BOOST_DEDUCED_TYPENAME range_return<Container,result_type>::type
                 operator()(Policy& policy, Container& cont)
                 {
-                    return boost::upper_bound<result_type>(
-                        cont, 5, policy.pred());
+                    typedef BOOST_DEDUCED_TYPENAME range_return<Container,result_type>::type result_t;
+                    
+                    result_t result = boost::upper_bound<result_type>(cont, 5, policy.pred());
+                    
+                    BOOST_CHECK( result == boost::upper_bound<result_type>(
+                        boost::make_iterator_range(cont), 5, policy.pred()) );
+                        
+                    return result;
                 }
             };