diff --git a/include/boost/algorithm/cxx11/all_of.hpp b/include/boost/algorithm/cxx11/all_of.hpp
index 2d05c75..b76cb3f 100644
--- a/include/boost/algorithm/cxx11/all_of.hpp
+++ b/include/boost/algorithm/cxx11/all_of.hpp
@@ -12,7 +12,7 @@
 #ifndef BOOST_ALGORITHM_ALL_OF_HPP
 #define BOOST_ALGORITHM_ALL_OF_HPP
 
-#include <algorithm>	// for std::all_of, if available
+#include <algorithm>    // for std::all_of, if available
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
diff --git a/include/boost/algorithm/cxx11/any_of.hpp b/include/boost/algorithm/cxx11/any_of.hpp
index f96358e..c3ab3ce 100644
--- a/include/boost/algorithm/cxx11/any_of.hpp
+++ b/include/boost/algorithm/cxx11/any_of.hpp
@@ -14,7 +14,7 @@
 #ifndef BOOST_ALGORITHM_ANY_OF_HPP
 #define BOOST_ALGORITHM_ANY_OF_HPP
 
-#include <algorithm>	// for std::any_of, if available
+#include <algorithm>    // for std::any_of, if available
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
diff --git a/include/boost/algorithm/cxx11/copy_if.hpp b/include/boost/algorithm/cxx11/copy_if.hpp
index 84048e7..6d0ba00 100644
--- a/include/boost/algorithm/cxx11/copy_if.hpp
+++ b/include/boost/algorithm/cxx11/copy_if.hpp
@@ -12,7 +12,7 @@
 #ifndef BOOST_ALGORITHM_COPY_IF_HPP
 #define BOOST_ALGORITHM_COPY_IF_HPP
 
-#include <algorithm>	// for std::copy_if, if available
+#include <algorithm>    // for std::copy_if, if available
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
diff --git a/include/boost/algorithm/cxx11/iota.hpp b/include/boost/algorithm/cxx11/iota.hpp
index cda7195..b4f0daf 100644
--- a/include/boost/algorithm/cxx11/iota.hpp
+++ b/include/boost/algorithm/cxx11/iota.hpp
@@ -71,4 +71,4 @@ OutputIterator iota_n ( OutputIterator out, T value, std::size_t n )
 
 }}
 
-#endif  // BOOST_ALGORITHM_IOTA_HPP
\ No newline at end of file
+#endif  // BOOST_ALGORITHM_IOTA_HPP
diff --git a/include/boost/algorithm/cxx11/is_partitioned.hpp b/include/boost/algorithm/cxx11/is_partitioned.hpp
index 98d7266..f665c76 100644
--- a/include/boost/algorithm/cxx11/is_partitioned.hpp
+++ b/include/boost/algorithm/cxx11/is_partitioned.hpp
@@ -12,7 +12,7 @@
 #ifndef BOOST_ALGORITHM_IS_PARTITIONED_HPP
 #define BOOST_ALGORITHM_IS_PARTITIONED_HPP
 
-#include <algorithm>	// for std::is_partitioned, if available
+#include <algorithm>    // for std::is_partitioned, if available
 
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
@@ -35,14 +35,14 @@ using std::is_partitioned;      // Section 25.3.13
 template <typename InputIterator, typename UnaryPredicate>
 bool is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p )
 {
-//	Run through the part that satisfy the predicate
+//  Run through the part that satisfy the predicate
     for ( ; first != last; ++first )
         if ( !p (*first))
-        	break;
-//	Now the part that does not satisfy the predicate
+            break;
+//  Now the part that does not satisfy the predicate
     for ( ; first != last; ++first )
         if ( p (*first))
-        	return false;
+            return false;
     return true;
 }
 #endif
@@ -62,4 +62,4 @@ bool is_partitioned ( const Range &r, UnaryPredicate p )
 
 }}
 
-#endif  // BOOST_ALGORITHM_IS_PARTITIONED_HPP
\ No newline at end of file
+#endif  // BOOST_ALGORITHM_IS_PARTITIONED_HPP
diff --git a/include/boost/algorithm/cxx11/is_permutation.hpp b/include/boost/algorithm/cxx11/is_permutation.hpp
index f03e0e5..33cb712 100644
--- a/include/boost/algorithm/cxx11/is_permutation.hpp
+++ b/include/boost/algorithm/cxx11/is_permutation.hpp
@@ -136,4 +136,4 @@ is_permutation ( const Range &r, ForwardIterator first2, BinaryPredicate pred )
 
 }}
 
-#endif  // BOOST_ALGORITHM_IS_PERMUTATION_HPP
\ No newline at end of file
+#endif  // BOOST_ALGORITHM_IS_PERMUTATION_HPP
diff --git a/include/boost/algorithm/cxx11/is_sorted.hpp b/include/boost/algorithm/cxx11/is_sorted.hpp
index ef2ec41..20180b7 100644
--- a/include/boost/algorithm/cxx11/is_sorted.hpp
+++ b/include/boost/algorithm/cxx11/is_sorted.hpp
@@ -94,7 +94,7 @@ using std::is_sorted;       // Section 25.4.1.5
 #endif
 
 ///
-///	-- Range based versions of the C++11 functions
+/// -- Range based versions of the C++11 functions
 ///
 
 /// \fn is_sorted_until ( const R &range, Pred p )
@@ -126,7 +126,7 @@ using std::is_sorted;       // Section 25.4.1.5
     }
 
 namespace detail {
-	typedef struct { typedef bool type; } bool_;
+    typedef struct { typedef bool type; } bool_;
 };
 
 /// \fn is_sorted ( const R &range, Pred p )
@@ -157,7 +157,7 @@ namespace detail {
 
 
 ///
-///	-- Range based versions of the C++11 functions
+/// -- Range based versions of the C++11 functions
 ///
 
 /// \fn is_increasing ( ForwardIterator first, ForwardIterator last )
diff --git a/include/boost/algorithm/cxx11/none_of.hpp b/include/boost/algorithm/cxx11/none_of.hpp
index 5ca0e6d..feae991 100644
--- a/include/boost/algorithm/cxx11/none_of.hpp
+++ b/include/boost/algorithm/cxx11/none_of.hpp
@@ -12,7 +12,7 @@
 #ifndef BOOST_ALGORITHM_NONE_OF_HPP
 #define BOOST_ALGORITHM_NONE_OF_HPP
 
-#include <algorithm>	// for std::none_of, if available
+#include <algorithm>    // for std::none_of, if available
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 
diff --git a/include/boost/algorithm/cxx11/partition_copy.hpp b/include/boost/algorithm/cxx11/partition_copy.hpp
index c9a8a35..15c4dd6 100644
--- a/include/boost/algorithm/cxx11/partition_copy.hpp
+++ b/include/boost/algorithm/cxx11/partition_copy.hpp
@@ -12,7 +12,7 @@
 #ifndef BOOST_ALGORITHM_PARTITION_COPY_HPP
 #define BOOST_ALGORITHM_PARTITION_COPY_HPP
 
-#include <algorithm>	// for std::partition_copy, if available
+#include <algorithm>    // for std::partition_copy, if available
 #include <utility>  // for make_pair
 
 #include <boost/range/begin.hpp>
diff --git a/include/boost/algorithm/cxx11/partition_point.hpp b/include/boost/algorithm/cxx11/partition_point.hpp
index 6dc2d3d..36d8384 100644
--- a/include/boost/algorithm/cxx11/partition_point.hpp
+++ b/include/boost/algorithm/cxx11/partition_point.hpp
@@ -12,7 +12,7 @@
 #ifndef BOOST_ALGORITHM_PARTITION_POINT_HPP
 #define BOOST_ALGORITHM_PARTITION_POINT_HPP
 
-#include <algorithm>	// for std::partition_point, if available
+#include <algorithm>    // for std::partition_point, if available
 
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
@@ -25,7 +25,7 @@ using std::partition_point;      // Section 25.3.13
 #else
 /// \fn partition_point ( ForwardIterator first, ForwardIterator last, Predicate p )
 /// \brief Given a partitioned range, returns the partition point, i.e, the first element 
-///		that does not satisfy p
+///     that does not satisfy p
 /// 
 /// \param first    The start of the input sequence
 /// \param last     One past the end of the input sequence
@@ -69,4 +69,4 @@ typename boost::range_iterator<Range> partition_point ( Range &r, Predicate p )
 
 }}
 
-#endif  // BOOST_ALGORITHM_PARTITION_POINT_HPP
\ No newline at end of file
+#endif  // BOOST_ALGORITHM_PARTITION_POINT_HPP
diff --git a/include/boost/algorithm/hex.hpp b/include/boost/algorithm/hex.hpp
index c598dcb..9e566eb 100644
--- a/include/boost/algorithm/hex.hpp
+++ b/include/boost/algorithm/hex.hpp
@@ -45,7 +45,7 @@ namespace boost { namespace algorithm {
     
     \struct non_hex_input    
     \brief  Thrown when a non-hex value (0-9, A-F) encountered when decoding.
-    			Contains the offending character
+                Contains the offending character
     
     \struct not_enough_input 
     \brief  Thrown when the input sequence unexpectedly ends
diff --git a/include/boost/algorithm/searching/knuth_morris_pratt.hpp b/include/boost/algorithm/searching/knuth_morris_pratt.hpp
index 941906d..fe970a5 100755
--- a/include/boost/algorithm/searching/knuth_morris_pratt.hpp
+++ b/include/boost/algorithm/searching/knuth_morris_pratt.hpp
@@ -32,7 +32,7 @@ namespace boost { namespace algorithm {
         * Random-access iterators
         * The two iterator types (I1 and I2) must "point to" the same underlying type.
 
-    http://en.wikipedia.org/wiki/Knuth–Morris–Pratt_algorithm
+    http://en.wikipedia.org/wiki/Knuth-Morris-Pratt_algorithm
     http://www.inf.fh-flensburg.de/lang/algorithmen/pattern/kmpen.htm
 */
 
diff --git a/test/copy_n_test1.cpp b/test/copy_n_test1.cpp
index addf9a2..69d8a46 100644
--- a/test/copy_n_test1.cpp
+++ b/test/copy_n_test1.cpp
@@ -22,60 +22,60 @@ namespace ba = boost::algorithm;
 template <typename Container>
 void test_sequence ( Container const &c ) {
 
-	typedef typename Container::value_type value_type;
-	std::vector<value_type> v;
-	
-//	Copy zero elements
-	v.clear ();
-	ba::copy_n ( c.begin (), 0, back_inserter ( v ));
-	BOOST_CHECK ( v.size () == 0 );
-	ba::copy_n ( c.begin (), 0U, back_inserter ( v ));
-	BOOST_CHECK ( v.size () == 0 );
+    typedef typename Container::value_type value_type;
+    std::vector<value_type> v;
+    
+//  Copy zero elements
+    v.clear ();
+    ba::copy_n ( c.begin (), 0, back_inserter ( v ));
+    BOOST_CHECK ( v.size () == 0 );
+    ba::copy_n ( c.begin (), 0U, back_inserter ( v ));
+    BOOST_CHECK ( v.size () == 0 );
 
-	if ( c.size () > 0 ) {	
-	//	Just one element
-		v.clear ();
-		ba::copy_n ( c.begin (), 1, back_inserter ( v ));
-		BOOST_CHECK ( v.size () == 1 );
-		BOOST_CHECK ( v[0] == *c.begin ());
-		
-		v.clear ();
-		ba::copy_n ( c.begin (), 1U, back_inserter ( v ));
-		BOOST_CHECK ( v.size () == 1 );
-		BOOST_CHECK ( v[0] == *c.begin ());
+    if ( c.size () > 0 ) {  
+    //  Just one element
+        v.clear ();
+        ba::copy_n ( c.begin (), 1, back_inserter ( v ));
+        BOOST_CHECK ( v.size () == 1 );
+        BOOST_CHECK ( v[0] == *c.begin ());
+        
+        v.clear ();
+        ba::copy_n ( c.begin (), 1U, back_inserter ( v ));
+        BOOST_CHECK ( v.size () == 1 );
+        BOOST_CHECK ( v[0] == *c.begin ());
 
-	//	Half the elements
-		v.clear ();
-		ba::copy_n ( c.begin (), c.size () / 2, back_inserter ( v ));
-		BOOST_CHECK ( v.size () == c.size () / 2);
-		BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
+    //  Half the elements
+        v.clear ();
+        ba::copy_n ( c.begin (), c.size () / 2, back_inserter ( v ));
+        BOOST_CHECK ( v.size () == c.size () / 2);
+        BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
 
-	//	Half the elements + 1
-		v.clear ();
-		ba::copy_n ( c.begin (), c.size () / 2 + 1, back_inserter ( v ));
-		BOOST_CHECK ( v.size () == c.size () / 2 + 1 );
-		BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
-	
-	//	All the elements
-		v.clear ();
-		ba::copy_n ( c.begin (), c.size (), back_inserter ( v ));
-		BOOST_CHECK ( v.size () == c.size ());
-		BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
-		}
-	}
+    //  Half the elements + 1
+        v.clear ();
+        ba::copy_n ( c.begin (), c.size () / 2 + 1, back_inserter ( v ));
+        BOOST_CHECK ( v.size () == c.size () / 2 + 1 );
+        BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
+    
+    //  All the elements
+        v.clear ();
+        ba::copy_n ( c.begin (), c.size (), back_inserter ( v ));
+        BOOST_CHECK ( v.size () == c.size ());
+        BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
+        }
+    }
 
 
 void test_sequence1 () {
-	std::vector<int> v;
-	for ( int i = 5; i < 15; ++i )
-		v.push_back ( i );
-	test_sequence  ( v );
-	
-	std::list<int> l;
-	for ( int i = 25; i > 15; --i )
-		l.push_back ( i );
-	test_sequence  ( l );	
-	}
+    std::vector<int> v;
+    for ( int i = 5; i < 15; ++i )
+        v.push_back ( i );
+    test_sequence  ( v );
+    
+    std::list<int> l;
+    for ( int i = 25; i > 15; --i )
+        l.push_back ( i );
+    test_sequence  ( l );   
+    }
 
 
 int test_main( int , char* [] )
diff --git a/test/find_if_not_test1.cpp b/test/find_if_not_test1.cpp
index 821cce9..b23285a 100644
--- a/test/find_if_not_test1.cpp
+++ b/test/find_if_not_test1.cpp
@@ -22,18 +22,18 @@ namespace ba = boost::algorithm;
 
 template <typename Container>
 typename Container::iterator offset_to_iter ( Container &v, int offset ) {
-	typename Container::iterator retval;
-	
-	if ( offset >= 0 ) {
-		retval = v.begin ();
-		std::advance ( retval, offset );
-		}
-	else {
-		retval = v.end ();
-		std::advance ( retval, offset + 1 );
-		}
-	return retval;
-	}
+    typename Container::iterator retval;
+    
+    if ( offset >= 0 ) {
+        retval = v.begin ();
+        std::advance ( retval, offset );
+        }
+    else {
+        retval = v.end ();
+        std::advance ( retval, offset + 1 );
+        }
+    return retval;
+    }
 
 template <typename Container, typename Predicate>
 void test_sequence ( Container &v, Predicate comp, int expected ) {
@@ -71,7 +71,7 @@ void test_sequence1 () {
     test_sequence ( v, less_than<int>(10), 5 );
     test_sequence ( v, less_than<int>(99), -1 );   // all elements satisfy 
 
-//	With bidirectional iterators.
+//  With bidirectional iterators.
     std::list<int> l;
     for ( int i = 5; i < 15; ++i )
         l.push_back ( i );
diff --git a/test/hex_fail1.cpp b/test/hex_fail1.cpp
index 7192245..cd17852 100644
--- a/test/hex_fail1.cpp
+++ b/test/hex_fail1.cpp
@@ -15,7 +15,7 @@
 #include <iostream>
 #include <vector>
 
-//	should not compile: vector is not an integral type
+//  should not compile: vector is not an integral type
 int test_main( int , char* [] )
 {
   std::vector<float> v;
diff --git a/test/hex_test3.cpp b/test/hex_test3.cpp
index cb91d95..e9a47a4 100644
--- a/test/hex_test3.cpp
+++ b/test/hex_test3.cpp
@@ -21,12 +21,12 @@ Try ostream_iterators
 
 template <typename char_type>
 void test_to_hex ( const char_type ** tests ) {
-	typedef std::basic_string<char_type> String;
-	typedef std::basic_ostringstream<char_type> Stream;
-	typedef std::ostream_iterator<char_type, char_type> Iter;
+    typedef std::basic_string<char_type> String;
+    typedef std::basic_ostringstream<char_type> Stream;
+    typedef std::ostream_iterator<char_type, char_type> Iter;
 
     for ( const char_type **p = tests; *p; p++ ) {
-    	String arg, argh;
+        String arg, argh;
         Stream one, two, three;
         arg.assign ( *p );
         boost::algorithm::hex ( *p, Iter ( one ));
@@ -49,12 +49,12 @@ void test_to_hex ( const char_type ** tests ) {
 
 template <typename char_type>
 void test_from_hex_success ( const char_type ** tests ) {
-	typedef std::basic_string<char_type> String;
-	typedef std::basic_ostringstream<char_type> Stream;
-	typedef std::ostream_iterator<char_type, char_type> Iter;
+    typedef std::basic_string<char_type> String;
+    typedef std::basic_ostringstream<char_type> Stream;
+    typedef std::ostream_iterator<char_type, char_type> Iter;
 
     for ( const char_type **p = tests; *p; p++ ) {
-    	String arg, argh;
+        String arg, argh;
         Stream one, two, three;
         arg.assign ( *p );
         boost::algorithm::unhex ( *p,                       Iter ( one ));
diff --git a/test/iota_test1.cpp b/test/iota_test1.cpp
index c567d1b..24fd0e3 100644
--- a/test/iota_test1.cpp
+++ b/test/iota_test1.cpp
@@ -16,60 +16,60 @@
 #include <vector>
 #include <list>
 
-//	Test to make sure a sequence is "correctly formed"; i.e, ascending by one
+//  Test to make sure a sequence is "correctly formed"; i.e, ascending by one
 template <typename Iterator, typename T>
 bool test_iota_results ( Iterator first, Iterator last, T initial_value ) {
-	if ( first == last ) return true;
-	if ( initial_value != *first ) return false;
-	Iterator prev = first;
-	while ( ++first != last ) {
-		if (( *first - *prev ) != 1	)
-			return false;
-		prev = first;
-		}
-	return true;
-	}
+    if ( first == last ) return true;
+    if ( initial_value != *first ) return false;
+    Iterator prev = first;
+    while ( ++first != last ) {
+        if (( *first - *prev ) != 1 )
+            return false;
+        prev = first;
+        }
+    return true;
+    }
 
 template <typename Range, typename T>
 bool test_iota_results ( const Range &r, T initial_value ) {
-	return test_iota_results (boost::begin (r), boost::end (r), initial_value );
+    return test_iota_results (boost::begin (r), boost::end (r), initial_value );
 }
 
 
 void test_ints () {
-	std::vector<int> v;
-	std::list<int> l;
+    std::vector<int> v;
+    std::list<int> l;
 
-	v.clear ();	v.reserve ( 10 );
-	boost::algorithm::iota ( v.begin (), v.end (), 23 );
-	BOOST_CHECK ( test_iota_results ( v.begin (), v.end (), 23 ));
-	
-	v.clear ();	v.reserve ( 19 );
-	boost::algorithm::iota ( v, 18 );
-	BOOST_CHECK ( test_iota_results ( v, 18 ));
-	
-	v.clear ();
-	boost::algorithm::iota_n ( std::back_inserter(v), 99, 20 );
-	BOOST_CHECK ( test_iota_results ( v, 99 ));
-	
+    v.clear (); v.reserve ( 10 );
+    boost::algorithm::iota ( v.begin (), v.end (), 23 );
+    BOOST_CHECK ( test_iota_results ( v.begin (), v.end (), 23 ));
+    
+    v.clear (); v.reserve ( 19 );
+    boost::algorithm::iota ( v, 18 );
+    BOOST_CHECK ( test_iota_results ( v, 18 ));
+    
+    v.clear ();
+    boost::algorithm::iota_n ( std::back_inserter(v), 99, 20 );
+    BOOST_CHECK ( test_iota_results ( v, 99 ));
+    
 /*
-	l.clear (); l.reserve ( 5 );
-	boost::algorithm::iota ( l.begin (), l.end (), 123 );
-	BOOST_CHECK ( test_iota_results ( l.begin (), l.end (), 123 ));
-	
-	l.clear (); l.reserve ( 9 );
-	boost::algorithm::iota ( l.begin (), l.end (), 87 );
-	BOOST_CHECK ( test_iota_results ( l.begin (), l.end (), 87 ));
+    l.clear (); l.reserve ( 5 );
+    boost::algorithm::iota ( l.begin (), l.end (), 123 );
+    BOOST_CHECK ( test_iota_results ( l.begin (), l.end (), 123 ));
+    
+    l.clear (); l.reserve ( 9 );
+    boost::algorithm::iota ( l.begin (), l.end (), 87 );
+    BOOST_CHECK ( test_iota_results ( l.begin (), l.end (), 87 ));
 */
 
-	l.clear ();
-	boost::algorithm::iota_n ( std::back_inserter(l), 99, 20 );
-	BOOST_CHECK ( test_iota_results ( l, 99 ));
-	
-	l.clear ();
-	boost::algorithm::iota_n ( std::front_inserter(l), 123, 20 );
-	BOOST_CHECK ( test_iota_results ( l.rbegin (), l.rend (), 123 ));
-	}
+    l.clear ();
+    boost::algorithm::iota_n ( std::back_inserter(l), 99, 20 );
+    BOOST_CHECK ( test_iota_results ( l, 99 ));
+    
+    l.clear ();
+    boost::algorithm::iota_n ( std::front_inserter(l), 123, 20 );
+    BOOST_CHECK ( test_iota_results ( l.rbegin (), l.rend (), 123 ));
+    }
 
 
 int test_main( int , char* [] )
diff --git a/test/is_partitioned_test1.cpp b/test/is_partitioned_test1.cpp
index 435ca5a..429ae7d 100644
--- a/test/is_partitioned_test1.cpp
+++ b/test/is_partitioned_test1.cpp
@@ -40,19 +40,19 @@ void test_sequence1 () {
     v.clear ();
     for ( int i = 5; i < 15; ++i )
         v.push_back ( i );
-    BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(3)));		// no elements
-    BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(6)));		// only the first element
-    BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(10)));	// in the middle somewhere
-    BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(99)));	// all elements satisfy 
+    BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(3)));      // no elements
+    BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(6)));      // only the first element
+    BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(10))); // in the middle somewhere
+    BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(99))); // all elements satisfy 
 
-//	With bidirectional iterators.
+//  With bidirectional iterators.
     std::list<int> l;
     for ( int i = 5; i < 15; ++i )
         l.push_back ( i );
-    BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(3)));		// no elements
-    BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(6)));		// only the first element
-    BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(10)));	// in the middle somewhere
-    BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(99)));		// all elements satisfy 
+    BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(3)));       // no elements
+    BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(6)));       // only the first element
+    BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(10)));  // in the middle somewhere
+    BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(99)));      // all elements satisfy 
     }
 
 
diff --git a/test/ordered_test.cpp b/test/ordered_test.cpp
index 3278955..42e1219 100644
--- a/test/ordered_test.cpp
+++ b/test/ordered_test.cpp
@@ -36,24 +36,24 @@ test_ordered(void)
           int nonConstantArray[] = { 1, 2, 2, 2, 5 };
     const int inOrderUntilTheEnd [] = { 0, 1, 2, 3, 4, 5, 6, 7, 6 };
 
-//	Begin/end checks
-	BOOST_CHECK (  ba::is_sorted (b_e(strictlyIncreasingValues)));
-	BOOST_CHECK ( !ba::is_sorted (b_e(randomValues)));
-	BOOST_CHECK (  ba::is_sorted (b_e(strictlyIncreasingValues), std::less<int>()));
-	BOOST_CHECK ( !ba::is_sorted (b_e(strictlyIncreasingValues), std::greater<int>()));
+//  Begin/end checks
+    BOOST_CHECK (  ba::is_sorted (b_e(strictlyIncreasingValues)));
+    BOOST_CHECK ( !ba::is_sorted (b_e(randomValues)));
+    BOOST_CHECK (  ba::is_sorted (b_e(strictlyIncreasingValues), std::less<int>()));
+    BOOST_CHECK ( !ba::is_sorted (b_e(strictlyIncreasingValues), std::greater<int>()));
 
-//	Range checks
-	BOOST_CHECK (  ba::is_sorted (a_range(strictlyIncreasingValues)));
-	BOOST_CHECK ( !ba::is_sorted (a_range(randomValues)));
-	BOOST_CHECK (  ba::is_sorted (a_range(strictlyIncreasingValues), std::less<int>()));
-	BOOST_CHECK ( !ba::is_sorted (a_range(strictlyIncreasingValues), std::greater<int>()));
+//  Range checks
+    BOOST_CHECK (  ba::is_sorted (a_range(strictlyIncreasingValues)));
+    BOOST_CHECK ( !ba::is_sorted (a_range(randomValues)));
+    BOOST_CHECK (  ba::is_sorted (a_range(strictlyIncreasingValues), std::less<int>()));
+    BOOST_CHECK ( !ba::is_sorted (a_range(strictlyIncreasingValues), std::greater<int>()));
 
     BOOST_CHECK (  ba::is_sorted_until ( b_e(strictlyIncreasingValues))                       ==      a_end(strictlyIncreasingValues));
     BOOST_CHECK (  ba::is_sorted_until ( b_e(strictlyIncreasingValues),     std::less<int>()) ==      a_end(strictlyIncreasingValues));
     BOOST_CHECK (  ba::is_sorted_until ( a_range(strictlyIncreasingValues))                   == boost::end(strictlyIncreasingValues));
     BOOST_CHECK (  ba::is_sorted_until ( a_range(strictlyIncreasingValues), std::less<int>()) == boost::end(strictlyIncreasingValues));
 
-//	Check for const and non-const arrays
+//  Check for const and non-const arrays
     BOOST_CHECK ( ba::is_sorted_until ( b_e(constantValues),       std::less<int>()) !=      a_end(constantValues));
     BOOST_CHECK ( ba::is_sorted_until ( a_range(constantValues),   std::less<int>()) != boost::end(constantValues));
     BOOST_CHECK ( ba::is_sorted_until ( b_e(nonConstantArray),     std::less<int>()) !=      a_end(nonConstantArray));
@@ -149,6 +149,6 @@ test_increasing_decreasing(void)
 int test_main( int, char * [] )
 {
     test_ordered ();
-	test_increasing_decreasing ();
+    test_increasing_decreasing ();
     return 0;
 }
diff --git a/test/partition_point_test1.cpp b/test/partition_point_test1.cpp
index ff4763e..4306a4a 100644
--- a/test/partition_point_test1.cpp
+++ b/test/partition_point_test1.cpp
@@ -22,18 +22,18 @@ namespace ba = boost::algorithm;
 
 template <typename Container>
 typename Container::iterator offset_to_iter ( Container &v, int offset ) {
-	typename Container::iterator retval;
-	
-	if ( offset >= 0 ) {
-		retval = v.begin ();
-		std::advance ( retval, offset );
-		}
-	else {
-		retval = v.end ();
-		std::advance ( retval, offset + 1 );
-		}
-	return retval;
-	}
+    typename Container::iterator retval;
+    
+    if ( offset >= 0 ) {
+        retval = v.begin ();
+        std::advance ( retval, offset );
+        }
+    else {
+        retval = v.end ();
+        std::advance ( retval, offset + 1 );
+        }
+    return retval;
+    }
 
 template <typename Container, typename Predicate>
 void test_sequence ( Container &v, Predicate comp, int expected ) {
@@ -79,7 +79,7 @@ void test_sequence1 () {
     test_sequence ( v, less_than<int>(10), 5 );
     test_sequence ( v, less_than<int>(99), -1 );   // all elements satisfy 
 
-//	With bidirectional iterators.
+//  With bidirectional iterators.
     std::list<int> l;
     for ( int i = 5; i < 15; ++i )
         l.push_back ( i );