From 1f0c9b71515d1ca170aabf024975ecd2ece217d6 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@pdimov.com>
Date: Thu, 18 Oct 2018 07:28:52 +0300
Subject: [PATCH] Untabify

---
 test/variant_copy_assign.cpp                 |  8 ++---
 test/variant_eq_ne.cpp                       |  2 +-
 test/variant_in_place_index_construct.cpp    | 32 ++++++++++----------
 test/variant_in_place_index_construct_cx.cpp | 26 ++++++++--------
 test/variant_in_place_type_construct.cpp     | 24 +++++++--------
 test/variant_in_place_type_construct_cx.cpp  | 20 ++++++------
 test/variant_lt_gt.cpp                       |  2 +-
 test/variant_move_assign.cpp                 |  8 ++---
 test/variant_swap.cpp                        |  8 ++---
 9 files changed, 65 insertions(+), 65 deletions(-)

diff --git a/test/variant_copy_assign.cpp b/test/variant_copy_assign.cpp
index 3211ecc..c8ed44f 100644
--- a/test/variant_copy_assign.cpp
+++ b/test/variant_copy_assign.cpp
@@ -108,7 +108,7 @@ int main()
         BOOST_TEST_EQ( v.index(), 0 );
         BOOST_TEST_EQ( get<0>(v), 0 );
 
-		variant<int, int, float, std::string> v2( in_place_index_t<1>{}, 1 );
+        variant<int, int, float, std::string> v2( in_place_index_t<1>{}, 1 );
 
         v = v2;
         BOOST_TEST_EQ( v.index(), 1 );
@@ -150,19 +150,19 @@ int main()
         BOOST_TEST_EQ( v.index(), 0 );
         BOOST_TEST_EQ( get<0>(v).v, 1 );
 
-		variant<X1, X2> v3( in_place_index_t<1>{}, 2 );
+        variant<X1, X2> v3( in_place_index_t<1>{}, 2 );
 
         v = v3;
         BOOST_TEST_EQ( v.index(), 1 );
         BOOST_TEST_EQ( get<1>(v).v, 2 );
 
-		variant<X1, X2> const v4( in_place_index_t<1>{}, 3 );
+        variant<X1, X2> const v4( in_place_index_t<1>{}, 3 );
 
         v = v4;
         BOOST_TEST_EQ( v.index(), 1 );
         BOOST_TEST_EQ( get<1>(v).v, 3 );
 
-		variant<X1, X2> const v5( in_place_index_t<0>{}, 4 );
+        variant<X1, X2> const v5( in_place_index_t<0>{}, 4 );
 
         v = v5;
         BOOST_TEST_EQ( v.index(), 0 );
diff --git a/test/variant_eq_ne.cpp b/test/variant_eq_ne.cpp
index d92f4f5..b2fc19d 100644
--- a/test/variant_eq_ne.cpp
+++ b/test/variant_eq_ne.cpp
@@ -60,7 +60,7 @@ int main()
     }
 
     {
-		variant<int, int, float> v1, v2, v3( in_place_index_t<1>{} ), v4( in_place_index_t<1>{} ), v5( 3.14f ), v6( 3.14f );
+        variant<int, int, float> v1, v2, v3( in_place_index_t<1>{} ), v4( in_place_index_t<1>{} ), v5( 3.14f ), v6( 3.14f );
 
         BOOST_TEST( v1 == v2 );
         BOOST_TEST_NOT( v1 != v2 );
diff --git a/test/variant_in_place_index_construct.cpp b/test/variant_in_place_index_construct.cpp
index d555b71..75821d3 100644
--- a/test/variant_in_place_index_construct.cpp
+++ b/test/variant_in_place_index_construct.cpp
@@ -24,111 +24,111 @@ struct X
 int main()
 {
     {
-		variant<int> v( in_place_index_t<0>{} );
+        variant<int> v( in_place_index_t<0>{} );
 
         BOOST_TEST_EQ( v.index(), 0 );
         BOOST_TEST_EQ( get<0>(v), 0 );
     }
 
     {
-		variant<X> v( in_place_index_t<0>{} );
+        variant<X> v( in_place_index_t<0>{} );
 
         BOOST_TEST_EQ( v.index(), 0 );
     }
 
     {
-		variant<int> v( in_place_index_t<0>{}, 1 );
+        variant<int> v( in_place_index_t<0>{}, 1 );
 
         BOOST_TEST_EQ( v.index(), 0 );
         BOOST_TEST_EQ( get<0>(v), 1 );
     }
 
     {
-		variant<int, float> v( in_place_index_t<0>{} );
+        variant<int, float> v( in_place_index_t<0>{} );
 
         BOOST_TEST_EQ( v.index(), 0 );
         BOOST_TEST_EQ( get<0>(v), 0 );
     }
 
     {
-		variant<int, float> v( in_place_index_t<0>{}, 1 );
+        variant<int, float> v( in_place_index_t<0>{}, 1 );
 
         BOOST_TEST_EQ( v.index(), 0 );
         BOOST_TEST_EQ( get<0>(v), 1 );
     }
 
     {
-		variant<int, float> v( in_place_index_t<1>{} );
+        variant<int, float> v( in_place_index_t<1>{} );
 
         BOOST_TEST_EQ( v.index(), 1 );
         BOOST_TEST_EQ( get<1>(v), 0 );
     }
 
     {
-		variant<int, float> v( in_place_index_t<1>{}, 3.14f );
+        variant<int, float> v( in_place_index_t<1>{}, 3.14f );
 
         BOOST_TEST_EQ( v.index(), 1 );
         BOOST_TEST_EQ( get<1>(v), 3.14f );
     }
 
     {
-		variant<int, int, float, float, std::string, std::string> v( in_place_index_t<0>{}, 1 );
+        variant<int, int, float, float, std::string, std::string> v( in_place_index_t<0>{}, 1 );
 
         BOOST_TEST_EQ( v.index(), 0 );
         BOOST_TEST_EQ( get<0>(v), 1 );
     }
 
     {
-		variant<int, int, float, float, std::string, std::string> v( in_place_index_t<1>{}, 1 );
+        variant<int, int, float, float, std::string, std::string> v( in_place_index_t<1>{}, 1 );
 
         BOOST_TEST_EQ( v.index(), 1 );
         BOOST_TEST_EQ( get<1>(v), 1 );
     }
 
     {
-		variant<int, int, float, float, std::string, std::string> v( in_place_index_t<2>{}, 3.14f );
+        variant<int, int, float, float, std::string, std::string> v( in_place_index_t<2>{}, 3.14f );
 
         BOOST_TEST_EQ( v.index(), 2 );
         BOOST_TEST_EQ( get<2>(v), 3.14f );
     }
 
     {
-		variant<int, int, float, float, std::string, std::string> v( in_place_index_t<3>{}, 3.14f );
+        variant<int, int, float, float, std::string, std::string> v( in_place_index_t<3>{}, 3.14f );
 
         BOOST_TEST_EQ( v.index(), 3 );
         BOOST_TEST_EQ( get<3>(v), 3.14f );
     }
 
     {
-		variant<int, int, float, float, std::string, std::string> v( in_place_index_t<4>{}, "text" );
+        variant<int, int, float, float, std::string, std::string> v( in_place_index_t<4>{}, "text" );
 
         BOOST_TEST_EQ( v.index(), 4 );
         BOOST_TEST_EQ( get<4>(v), std::string("text") );
     }
 
     {
-		variant<int, int, float, float, std::string, std::string> v( in_place_index_t<5>{}, "text" );
+        variant<int, int, float, float, std::string, std::string> v( in_place_index_t<5>{}, "text" );
 
         BOOST_TEST_EQ( v.index(), 5 );
         BOOST_TEST_EQ( get<5>(v), std::string("text") );
     }
 
     {
-		variant<int, int, float, float, std::string, std::string> v( in_place_index_t<5>{}, 4, 'a' );
+        variant<int, int, float, float, std::string, std::string> v( in_place_index_t<5>{}, 4, 'a' );
 
         BOOST_TEST_EQ( v.index(), 5 );
         BOOST_TEST_EQ( get<5>(v), std::string( 4, 'a' ) );
     }
 
     {
-		variant<int, int, float, float, std::string, std::string> v( in_place_index_t<4>{}, { 'a', 'b', 'c' } );
+        variant<int, int, float, float, std::string, std::string> v( in_place_index_t<4>{}, { 'a', 'b', 'c' } );
 
         BOOST_TEST_EQ( v.index(), 4 );
         BOOST_TEST_EQ( get<4>(v), (std::string{ 'a', 'b', 'c' }) );
     }
 
     {
-		variant<int, int, float, float, std::string, std::string> v( in_place_index_t<5>{}, { 'a', 'b', 'c' }, std::allocator<char>() );
+        variant<int, int, float, float, std::string, std::string> v( in_place_index_t<5>{}, { 'a', 'b', 'c' }, std::allocator<char>() );
 
         BOOST_TEST_EQ( v.index(), 5 );
         BOOST_TEST_EQ( get<5>(v), (std::string{ 'a', 'b', 'c' }) );
diff --git a/test/variant_in_place_index_construct_cx.cpp b/test/variant_in_place_index_construct_cx.cpp
index 24f93a4..80a6934 100644
--- a/test/variant_in_place_index_construct_cx.cpp
+++ b/test/variant_in_place_index_construct_cx.cpp
@@ -27,89 +27,89 @@ struct X
 int main()
 {
     {
-		constexpr variant<int> v( in_place_index_t<0>{} );
+        constexpr variant<int> v( in_place_index_t<0>{} );
 
         STATIC_ASSERT( v.index() == 0 );
         STATIC_ASSERT( get<0>(v) == 0 );
     }
 
     {
-		constexpr variant<X> v( in_place_index_t<0>{} );
+        constexpr variant<X> v( in_place_index_t<0>{} );
 
         STATIC_ASSERT( v.index() == 0 );
     }
 
     {
-		constexpr variant<int> v( in_place_index_t<0>{}, 1 );
+        constexpr variant<int> v( in_place_index_t<0>{}, 1 );
 
         STATIC_ASSERT( v.index() == 0 );
         STATIC_ASSERT( get<0>(v) == 1 );
     }
 
     {
-		constexpr variant<int, float> v( in_place_index_t<0>{} );
+        constexpr variant<int, float> v( in_place_index_t<0>{} );
 
         STATIC_ASSERT( v.index() == 0 );
         STATIC_ASSERT( get<0>(v) == 0 );
     }
 
     {
-		constexpr variant<int, float> v( in_place_index_t<0>{}, 1 );
+        constexpr variant<int, float> v( in_place_index_t<0>{}, 1 );
 
         STATIC_ASSERT( v.index() == 0 );
         STATIC_ASSERT( get<0>(v) == 1 );
     }
 
     {
-		constexpr variant<int, float> v( in_place_index_t<1>{} );
+        constexpr variant<int, float> v( in_place_index_t<1>{} );
 
         STATIC_ASSERT( v.index() == 1 );
         STATIC_ASSERT( get<1>(v) == 0 );
     }
 
     {
-		constexpr variant<int, float> v( in_place_index_t<1>{}, 3.14f );
+        constexpr variant<int, float> v( in_place_index_t<1>{}, 3.14f );
 
         STATIC_ASSERT( v.index() == 1 );
         STATIC_ASSERT( get<1>(v) == 3.14f );
     }
 
     {
-		constexpr variant<int, int, float, float, X, X> v( in_place_index_t<0>{}, 1 );
+        constexpr variant<int, int, float, float, X, X> v( in_place_index_t<0>{}, 1 );
 
         STATIC_ASSERT( v.index() == 0 );
         STATIC_ASSERT( get<0>(v) == 1 );
     }
 
     {
-		constexpr variant<int, int, float, float, X, X> v( in_place_index_t<1>{}, 1 );
+        constexpr variant<int, int, float, float, X, X> v( in_place_index_t<1>{}, 1 );
 
         STATIC_ASSERT( v.index() == 1 );
         STATIC_ASSERT( get<1>(v) == 1 );
     }
 
     {
-		constexpr variant<int, int, float, float, X, X> v( in_place_index_t<2>{}, 3.14f );
+        constexpr variant<int, int, float, float, X, X> v( in_place_index_t<2>{}, 3.14f );
 
         STATIC_ASSERT( v.index() == 2 );
         STATIC_ASSERT( get<2>(v) == 3.14f );
     }
 
     {
-		constexpr variant<int, int, float, float, X, X> v( in_place_index_t<3>{}, 3.14f );
+        constexpr variant<int, int, float, float, X, X> v( in_place_index_t<3>{}, 3.14f );
 
         STATIC_ASSERT( v.index() == 3 );
         STATIC_ASSERT( get<3>(v) == 3.14f );
     }
 
     {
-		constexpr variant<int, int, float, float, X, X> v( in_place_index_t<4>{} );
+        constexpr variant<int, int, float, float, X, X> v( in_place_index_t<4>{} );
 
         STATIC_ASSERT( v.index() == 4 );
     }
 
     {
-		constexpr variant<int, int, float, float, X, X> v( in_place_index_t<5>{}, 0, 0 );
+        constexpr variant<int, int, float, float, X, X> v( in_place_index_t<5>{}, 0, 0 );
 
         STATIC_ASSERT( v.index() == 5 );
     }
diff --git a/test/variant_in_place_type_construct.cpp b/test/variant_in_place_type_construct.cpp
index 6ba38c7..3c8265a 100644
--- a/test/variant_in_place_type_construct.cpp
+++ b/test/variant_in_place_type_construct.cpp
@@ -24,7 +24,7 @@ struct X
 int main()
 {
     {
-		variant<int> v( in_place_type_t<int>{} );
+        variant<int> v( in_place_type_t<int>{} );
 
         BOOST_TEST_EQ( v.index(), 0 );
         BOOST_TEST_EQ( get<0>(v), 0 );
@@ -33,7 +33,7 @@ int main()
     }
 
     {
-		variant<X> v( in_place_type_t<X>{} );
+        variant<X> v( in_place_type_t<X>{} );
 
         BOOST_TEST_EQ( v.index(), 0 );
 
@@ -41,7 +41,7 @@ int main()
     }
 
     {
-		variant<int> v( in_place_type_t<int>{}, 1 );
+        variant<int> v( in_place_type_t<int>{}, 1 );
 
         BOOST_TEST_EQ( v.index(), 0 );
         BOOST_TEST_EQ( get<0>(v), 1 );
@@ -50,7 +50,7 @@ int main()
     }
 
     {
-		variant<int, float> v( in_place_type_t<int>{} );
+        variant<int, float> v( in_place_type_t<int>{} );
 
         BOOST_TEST_EQ( v.index(), 0 );
         BOOST_TEST_EQ( get<0>(v), 0 );
@@ -59,7 +59,7 @@ int main()
     }
 
     {
-		variant<int, float> v( in_place_type_t<int>{}, 1 );
+        variant<int, float> v( in_place_type_t<int>{}, 1 );
 
         BOOST_TEST_EQ( v.index(), 0 );
         BOOST_TEST_EQ( get<0>(v), 1 );
@@ -68,7 +68,7 @@ int main()
     }
 
     {
-		variant<int, float> v( in_place_type_t<float>{} );
+        variant<int, float> v( in_place_type_t<float>{} );
 
         BOOST_TEST_EQ( v.index(), 1 );
         BOOST_TEST_EQ( get<1>(v), 0 );
@@ -77,7 +77,7 @@ int main()
     }
 
     {
-		variant<int, float> v( in_place_type_t<float>{}, 3.14f );
+        variant<int, float> v( in_place_type_t<float>{}, 3.14f );
 
         BOOST_TEST_EQ( v.index(), 1 );
         BOOST_TEST_EQ( get<1>(v), 3.14f );
@@ -86,7 +86,7 @@ int main()
     }
 
     {
-		variant<int, int, float, std::string> v( in_place_type_t<float>{}, 3.14f );
+        variant<int, int, float, std::string> v( in_place_type_t<float>{}, 3.14f );
 
         BOOST_TEST_EQ( v.index(), 2 );
         BOOST_TEST_EQ( get<2>(v), 3.14f );
@@ -95,7 +95,7 @@ int main()
     }
 
     {
-		variant<int, int, float, float, std::string> v( in_place_type_t<std::string>{}, "text" );
+        variant<int, int, float, float, std::string> v( in_place_type_t<std::string>{}, "text" );
 
         BOOST_TEST_EQ( v.index(), 4 );
         BOOST_TEST_EQ( get<4>(v), std::string("text") );
@@ -104,7 +104,7 @@ int main()
     }
 
     {
-		variant<int, int, float, float, std::string> v( in_place_type_t<std::string>{}, 4, 'a' );
+        variant<int, int, float, float, std::string> v( in_place_type_t<std::string>{}, 4, 'a' );
 
         BOOST_TEST_EQ( v.index(), 4 );
         BOOST_TEST_EQ( get<4>(v), std::string( 4, 'a' ) );
@@ -113,7 +113,7 @@ int main()
     }
 
     {
-		variant<int, int, float, float, std::string> v( in_place_type_t<std::string>{}, { 'a', 'b', 'c' } );
+        variant<int, int, float, float, std::string> v( in_place_type_t<std::string>{}, { 'a', 'b', 'c' } );
 
         BOOST_TEST_EQ( v.index(), 4 );
         BOOST_TEST_EQ( get<4>(v), (std::string{ 'a', 'b', 'c' }) );
@@ -122,7 +122,7 @@ int main()
     }
 
     {
-		variant<int, int, float, float, std::string> v( in_place_type_t<std::string>{}, { 'a', 'b', 'c' }, std::allocator<char>() );
+        variant<int, int, float, float, std::string> v( in_place_type_t<std::string>{}, { 'a', 'b', 'c' }, std::allocator<char>() );
 
         BOOST_TEST_EQ( v.index(), 4 );
         BOOST_TEST_EQ( get<4>(v), (std::string{ 'a', 'b', 'c' }) );
diff --git a/test/variant_in_place_type_construct_cx.cpp b/test/variant_in_place_type_construct_cx.cpp
index 219abc6..a64c347 100644
--- a/test/variant_in_place_type_construct_cx.cpp
+++ b/test/variant_in_place_type_construct_cx.cpp
@@ -22,7 +22,7 @@ struct X
 int main()
 {
     {
-		constexpr variant<int> v( in_place_type_t<int>{} );
+        constexpr variant<int> v( in_place_type_t<int>{} );
 
         STATIC_ASSERT( v.index() == 0 );
         STATIC_ASSERT( get<0>(v) == 0 );
@@ -31,7 +31,7 @@ int main()
     }
 
     {
-		constexpr variant<X> v( in_place_type_t<X>{} );
+        constexpr variant<X> v( in_place_type_t<X>{} );
 
         STATIC_ASSERT( v.index() == 0 );
 
@@ -39,7 +39,7 @@ int main()
     }
 
     {
-		constexpr variant<int> v( in_place_type_t<int>{}, 1 );
+        constexpr variant<int> v( in_place_type_t<int>{}, 1 );
 
         STATIC_ASSERT( v.index() == 0 );
         STATIC_ASSERT( get<0>(v) == 1 );
@@ -48,7 +48,7 @@ int main()
     }
 
     {
-		constexpr variant<int, float> v( in_place_type_t<int>{} );
+        constexpr variant<int, float> v( in_place_type_t<int>{} );
 
         STATIC_ASSERT( v.index() == 0 );
         STATIC_ASSERT( get<0>(v) == 0 );
@@ -57,7 +57,7 @@ int main()
     }
 
     {
-		constexpr variant<int, float> v( in_place_type_t<int>{}, 1 );
+        constexpr variant<int, float> v( in_place_type_t<int>{}, 1 );
 
         STATIC_ASSERT( v.index() == 0 );
         STATIC_ASSERT( get<0>(v) == 1 );
@@ -66,7 +66,7 @@ int main()
     }
 
     {
-		constexpr variant<int, float> v( in_place_type_t<float>{} );
+        constexpr variant<int, float> v( in_place_type_t<float>{} );
 
         STATIC_ASSERT( v.index() == 1 );
         STATIC_ASSERT( get<1>(v) == 0 );
@@ -75,7 +75,7 @@ int main()
     }
 
     {
-		constexpr variant<int, float> v( in_place_type_t<float>{}, 3.14f );
+        constexpr variant<int, float> v( in_place_type_t<float>{}, 3.14f );
 
         STATIC_ASSERT( v.index() == 1 );
         STATIC_ASSERT( get<1>(v) == 3.14f );
@@ -84,7 +84,7 @@ int main()
     }
 
     {
-		constexpr variant<int, int, float, X> v( in_place_type_t<float>{}, 3.14f );
+        constexpr variant<int, int, float, X> v( in_place_type_t<float>{}, 3.14f );
 
         STATIC_ASSERT( v.index() == 2 );
         STATIC_ASSERT( get<2>(v) == 3.14f );
@@ -93,7 +93,7 @@ int main()
     }
 
     {
-		constexpr variant<int, int, float, float, X> v( in_place_type_t<X>{} );
+        constexpr variant<int, int, float, float, X> v( in_place_type_t<X>{} );
 
         STATIC_ASSERT( v.index() == 4 );
 
@@ -101,7 +101,7 @@ int main()
     }
 
     {
-		constexpr variant<int, int, float, float, X> v( in_place_type_t<X>{}, 0, 0 );
+        constexpr variant<int, int, float, float, X> v( in_place_type_t<X>{}, 0, 0 );
 
         STATIC_ASSERT( v.index() == 4 );
 
diff --git a/test/variant_lt_gt.cpp b/test/variant_lt_gt.cpp
index 61ff8cc..688209f 100644
--- a/test/variant_lt_gt.cpp
+++ b/test/variant_lt_gt.cpp
@@ -62,7 +62,7 @@ int main()
     }
 
     {
-		variant<int, int, float> v1, v2, v3( in_place_index_t<1>{} ), v4( in_place_index_t<1>{} ), v5( 3.14f ), v6( 3.14f );
+        variant<int, int, float> v1, v2, v3( in_place_index_t<1>{} ), v4( in_place_index_t<1>{} ), v5( 3.14f ), v6( 3.14f );
 
         TEST_EQ( v1, v2 )
         TEST_LE( v1, v3 )
diff --git a/test/variant_move_assign.cpp b/test/variant_move_assign.cpp
index 9d78a03..632f068 100644
--- a/test/variant_move_assign.cpp
+++ b/test/variant_move_assign.cpp
@@ -108,7 +108,7 @@ int main()
         BOOST_TEST_EQ( v.index(), 0 );
         BOOST_TEST_EQ( get<0>(v), 0 );
 
-		variant<int, int, float, std::string> v2( in_place_index_t<1>{}, 1 );
+        variant<int, int, float, std::string> v2( in_place_index_t<1>{}, 1 );
 
         v = std::move(v2);
         BOOST_TEST_EQ( v.index(), 1 );
@@ -150,19 +150,19 @@ int main()
         BOOST_TEST_EQ( v.index(), 0 );
         BOOST_TEST_EQ( get<0>(v).v, 1 );
 
-		variant<X1, X2> v3( in_place_index_t<1>{}, 2 );
+        variant<X1, X2> v3( in_place_index_t<1>{}, 2 );
 
         v = std::move(v3);
         BOOST_TEST_EQ( v.index(), 1 );
         BOOST_TEST_EQ( get<1>(v).v, 2 );
 
-		variant<X1, X2> v4( in_place_index_t<1>{}, 3 );
+        variant<X1, X2> v4( in_place_index_t<1>{}, 3 );
 
         v = std::move(v4);
         BOOST_TEST_EQ( v.index(), 1 );
         BOOST_TEST_EQ( get<1>(v).v, 3 );
 
-		variant<X1, X2> v5( in_place_index_t<0>{}, 4 );
+        variant<X1, X2> v5( in_place_index_t<0>{}, 4 );
 
         v = std::move(v5);
         BOOST_TEST_EQ( v.index(), 0 );
diff --git a/test/variant_swap.cpp b/test/variant_swap.cpp
index 560ca69..3e80f0f 100644
--- a/test/variant_swap.cpp
+++ b/test/variant_swap.cpp
@@ -130,7 +130,7 @@ int main()
         BOOST_TEST_EQ( v.index(), 0 );
         BOOST_TEST_EQ( get<0>(v), 0 );
 
-		variant<int, int, float, std::string> v2( in_place_index_t<1>{}, 1 );
+        variant<int, int, float, std::string> v2( in_place_index_t<1>{}, 1 );
 
         BOOST_TEST_EQ( v2.index(), 1 );
         BOOST_TEST_EQ( get<1>(v2), 1 );
@@ -215,7 +215,7 @@ int main()
         BOOST_TEST_EQ( v2.index(), 0 );
         BOOST_TEST_EQ( get<0>(v2).v, 0 );
 
-		variant<X1, X2> v3( in_place_index_t<1>{}, 2 );
+        variant<X1, X2> v3( in_place_index_t<1>{}, 2 );
 
         BOOST_TEST_EQ( v3.index(), 1 );
         BOOST_TEST_EQ( get<1>(v3).v, 2 );
@@ -228,7 +228,7 @@ int main()
         BOOST_TEST_EQ( v3.index(), 0 );
         BOOST_TEST_EQ( get<0>(v3).v, 1 );
 
-		variant<X1, X2> v4( in_place_index_t<1>{}, 3 );
+        variant<X1, X2> v4( in_place_index_t<1>{}, 3 );
 
         BOOST_TEST_EQ( v4.index(), 1 );
         BOOST_TEST_EQ( get<1>(v4).v, 3 );
@@ -241,7 +241,7 @@ int main()
         BOOST_TEST_EQ( v4.index(), 1 );
         BOOST_TEST_EQ( get<1>(v4).v, 2 );
 
-		variant<X1, X2> v5( in_place_index_t<0>{}, 4 );
+        variant<X1, X2> v5( in_place_index_t<0>{}, 4 );
 
         BOOST_TEST_EQ( v5.index(), 0 );
         BOOST_TEST_EQ( get<0>(v5).v, 4 );