diff --git a/test/capture_exception_async_test.cpp b/test/capture_exception_async_test.cpp
index a2a1972..0b82751 100644
--- a/test/capture_exception_async_test.cpp
+++ b/test/capture_exception_async_test.cpp
@@ -67,8 +67,8 @@ int main()
 			},
 			[&]( info<1> const & x1, info<2> const & x2 )
 			{
-				BOOST_TEST(x1.value==f.a);
-				BOOST_TEST(x2.value==f.b);
+				BOOST_TEST_EQ(x1.value, f.a);
+				BOOST_TEST_EQ(x2.value, f.b);
 				return -1;
 			},
 			[ ]
@@ -76,9 +76,9 @@ int main()
 				return -2;
 			} );
 		if( f.result>=0 )
-			BOOST_TEST(r==f.result);
+			BOOST_TEST_EQ(r, f.result);
 		else
-			BOOST_TEST(r==-1);
+			BOOST_TEST_EQ(r, -1);
 	}
 
 	return boost::report_errors();
diff --git a/test/capture_exception_state_test.cpp b/test/capture_exception_state_test.cpp
index 80f3150..4d0d2e7 100644
--- a/test/capture_exception_state_test.cpp
+++ b/test/capture_exception_state_test.cpp
@@ -46,14 +46,14 @@ int main()
 	leaf::try_(
 		[&f]
 		{
-			BOOST_TEST(count==0);
+			BOOST_TEST_EQ(count, 0);
 			try { f(); }
-			catch(...) { BOOST_TEST(count==2); throw; }
+			catch(...) { BOOST_TEST_EQ(count, 2); throw; }
 
 		},
 		[ ]
 		{
 		} );
-	BOOST_TEST(count==0);
+	BOOST_TEST_EQ(count, 0);
 	return boost::report_errors();
 }
diff --git a/test/capture_exception_unload_test.cpp b/test/capture_exception_unload_test.cpp
index 2d2c692..3b7f792 100644
--- a/test/capture_exception_unload_test.cpp
+++ b/test/capture_exception_unload_test.cpp
@@ -28,16 +28,16 @@ void test( F f_ )
 			},
 			[&c]( info<1> const & x )
 			{
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			},
 			[&c]
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			} );
-		BOOST_TEST(c==1);
+		BOOST_TEST_EQ(c, 1);
 	}
 
 	{
@@ -49,16 +49,16 @@ void test( F f_ )
 			},
 			[&c]( info<2> const & x )
 			{
-				BOOST_TEST(x.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			},
 			[&c]
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 	}
 
 	{
@@ -69,14 +69,14 @@ void test( F f_ )
 			},
 			[ ]( info<1> const & x )
 			{
-				BOOST_TEST(x.value==1);
+				BOOST_TEST_EQ(x.value, 1);
 				return 1;
 			},
 			[ ]
 			{
 				return 2;
 			} );
-		BOOST_TEST(r==1);
+		BOOST_TEST_EQ(r, 1);
 	}
 
 	{
@@ -87,14 +87,14 @@ void test( F f_ )
 			},
 			[ ]( info<2> const & x )
 			{
-				BOOST_TEST(x.value==2);
+				BOOST_TEST_EQ(x.value, 2);
 				return 1;
 			},
 			[ ]
 			{
 				return 2;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 
 	{
@@ -109,8 +109,8 @@ void test( F f_ )
 			},
 			[ ]( info<1> const & x, info<3> const & y )
 			{
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==3);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 3);
 				return false;
 			},
 			[ ]( info<1> const & x )
@@ -136,8 +136,8 @@ void test( F f_ )
 			},
 			[ ]( info<1> const & x, info<3> const & y )
 			{
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==3);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 3);
 				return true;
 			},
 			[ ]( info<1> const & x )
diff --git a/test/capture_result_async_test.cpp b/test/capture_result_async_test.cpp
index dd2d76f..685c8e9 100644
--- a/test/capture_result_async_test.cpp
+++ b/test/capture_result_async_test.cpp
@@ -67,8 +67,8 @@ int main()
 			},
 			[&]( info<1> const & x1, info<2> const & x2 )
 			{
-				BOOST_TEST(x1.value==f.a);
-				BOOST_TEST(x2.value==f.b);
+				BOOST_TEST_EQ(x1.value, f.a);
+				BOOST_TEST_EQ(x2.value, f.b);
 				return -1;
 			},
 			[ ]
@@ -76,9 +76,9 @@ int main()
 				return -2;
 			} );
 		if( f.result>=0 )
-			BOOST_TEST(r==f.result);
+			BOOST_TEST_EQ(r, f.result);
 		else
-			BOOST_TEST(r==-1);
+			BOOST_TEST_EQ(r, -1);
 	}
 
 	return boost::report_errors();
diff --git a/test/capture_result_state_test.cpp b/test/capture_result_state_test.cpp
index a11561c..73d2feb 100644
--- a/test/capture_result_state_test.cpp
+++ b/test/capture_result_state_test.cpp
@@ -46,14 +46,14 @@ int main()
 	leaf::handle_all(
 		[&f]
 		{
-			BOOST_TEST(count==0);
+			BOOST_TEST_EQ(count, 0);
 			auto r = f();
-			BOOST_TEST(count==2);
+			BOOST_TEST_EQ(count, 2);
 			return r;
 		},
 		[ ]
 		{
 		} );
-	BOOST_TEST(count==0);
+	BOOST_TEST_EQ(count, 0);
 	return boost::report_errors();
 }
diff --git a/test/capture_result_unload_test.cpp b/test/capture_result_unload_test.cpp
index fd05cc9..4904e3b 100644
--- a/test/capture_result_unload_test.cpp
+++ b/test/capture_result_unload_test.cpp
@@ -28,16 +28,16 @@ void test( F f_ )
 			},
 			[&c]( info<1> const & x )
 			{
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			},
 			[&c]
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			} );
-		BOOST_TEST(c==1);
+		BOOST_TEST_EQ(c, 1);
 	}
 
 	{
@@ -49,16 +49,16 @@ void test( F f_ )
 			},
 			[&c]( info<2> const & x )
 			{
-				BOOST_TEST(x.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			},
 			[&c]
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 	}
 
 	{
@@ -69,14 +69,14 @@ void test( F f_ )
 			},
 			[ ]( info<1> const & x )
 			{
-				BOOST_TEST(x.value==1);
+				BOOST_TEST_EQ(x.value, 1);
 				return 1;
 			},
 			[ ]
 			{
 				return 2;
 			} );
-		BOOST_TEST(r==1);
+		BOOST_TEST_EQ(r, 1);
 	}
 
 	{
@@ -87,14 +87,14 @@ void test( F f_ )
 			},
 			[ ]( info<2> const & x )
 			{
-				BOOST_TEST(x.value==2);
+				BOOST_TEST_EQ(x.value, 2);
 				return 1;
 			},
 			[ ]
 			{
 				return 2;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 
 	{
@@ -109,8 +109,8 @@ void test( F f_ )
 			},
 			[ ]( info<1> const & x, info<3> const & y )
 			{
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==3);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 3);
 				return false;
 			},
 			[ ]( info<1> const & x )
@@ -136,8 +136,8 @@ void test( F f_ )
 			},
 			[ ]( info<1> const & x, info<3> const & y )
 			{
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==3);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 3);
 				return true;
 			},
 			[ ]( info<1> const & x )
diff --git a/test/defer_basic_test.cpp b/test/defer_basic_test.cpp
index 4268809..64bb41f 100644
--- a/test/defer_basic_test.cpp
+++ b/test/defer_basic_test.cpp
@@ -45,13 +45,13 @@ int main()
 		},
 		[ ]( info const & i42 )
 		{
-			BOOST_TEST(i42.value==42);
+			BOOST_TEST_EQ(i42.value, 42);
 			return 1;
 		},
 		[ ]
 		{
 			return 2;
 		} );
-	BOOST_TEST(r==1);
+	BOOST_TEST_EQ(r, 1);
 	return boost::report_errors();
 }
diff --git a/test/defer_nested_error_exception_test.cpp b/test/defer_nested_error_exception_test.cpp
index 4e72254..561c9f9 100644
--- a/test/defer_nested_error_exception_test.cpp
+++ b/test/defer_nested_error_exception_test.cpp
@@ -52,17 +52,17 @@ int main()
 		},
 		[ ]( info<0> i0, info<1> i1, info<2> i2, info<3> i3 )
 		{
-			BOOST_TEST(i0.value==0);
-			BOOST_TEST(i1.value==1);
-			BOOST_TEST(i2.value==2);
-			BOOST_TEST(i3.value==3);
+			BOOST_TEST_EQ(i0.value, 0);
+			BOOST_TEST_EQ(i1.value, 1);
+			BOOST_TEST_EQ(i2.value, 2);
+			BOOST_TEST_EQ(i3.value, 3);
 			return 1;
 		},
 		[ ]
 		{
 			return 2;
 		} );
-	BOOST_TEST(r==1);
+	BOOST_TEST_EQ(r, 1);
 
 	return boost::report_errors();
 }
diff --git a/test/defer_nested_error_result_test.cpp b/test/defer_nested_error_result_test.cpp
index d3e9715..a34afe4 100644
--- a/test/defer_nested_error_result_test.cpp
+++ b/test/defer_nested_error_result_test.cpp
@@ -43,17 +43,17 @@ int main()
 		},
 		[ ]( info<0> i0, info<1> i1, info<2> i2, info<3> i3 )
 		{
-			BOOST_TEST(i0.value==0);
-			BOOST_TEST(i1.value==1);
-			BOOST_TEST(i2.value==2);
-			BOOST_TEST(i3.value==3);
+			BOOST_TEST_EQ(i0.value, 0);
+			BOOST_TEST_EQ(i1.value, 1);
+			BOOST_TEST_EQ(i2.value, 2);
+			BOOST_TEST_EQ(i3.value, 3);
 			return 1;
 		},
 		[ ]
 		{
 			return 2;
 		} );
-	BOOST_TEST(r==1);
+	BOOST_TEST_EQ(r, 1);
 
 	return boost::report_errors();
 }
diff --git a/test/defer_nested_new_error_exception_test.cpp b/test/defer_nested_new_error_exception_test.cpp
index 3b05b48..8b2e9b3 100644
--- a/test/defer_nested_new_error_exception_test.cpp
+++ b/test/defer_nested_new_error_exception_test.cpp
@@ -59,17 +59,17 @@ int main()
 		},
 		[ ]( info<0> i0, info<1> i1, info<2> i2, info<3> i3 )
 		{
-			BOOST_TEST(i0.value==0);
-			BOOST_TEST(i1.value==1);
-			BOOST_TEST(i2.value==2);
-			BOOST_TEST(i3.value==3);
+			BOOST_TEST_EQ(i0.value, 0);
+			BOOST_TEST_EQ(i1.value, 1);
+			BOOST_TEST_EQ(i2.value, 2);
+			BOOST_TEST_EQ(i3.value, 3);
 			return 1;
 		},
 		[ ]
 		{
 			return 2;
 		} );
-	BOOST_TEST(r==1);
+	BOOST_TEST_EQ(r, 1);
 
 	return boost::report_errors();
 }
diff --git a/test/defer_nested_new_error_result_test.cpp b/test/defer_nested_new_error_result_test.cpp
index 6b9c6f3..b457ffa 100644
--- a/test/defer_nested_new_error_result_test.cpp
+++ b/test/defer_nested_new_error_result_test.cpp
@@ -44,17 +44,17 @@ int main()
 		},
 		[ ]( info<0> i0, info<1> i1, info<2> i2, info<3> i3 )
 		{
-			BOOST_TEST(i0.value==0);
-			BOOST_TEST(i1.value==1);
-			BOOST_TEST(i2.value==2);
-			BOOST_TEST(i3.value==3);
+			BOOST_TEST_EQ(i0.value, 0);
+			BOOST_TEST_EQ(i1.value, 1);
+			BOOST_TEST_EQ(i2.value, 2);
+			BOOST_TEST_EQ(i3.value, 3);
 			return 1;
 		},
 		[ ]
 		{
 			return 2;
 		} );
-	BOOST_TEST(r==1);
+	BOOST_TEST_EQ(r, 1);
 
 	return boost::report_errors();
 }
diff --git a/test/defer_nested_success_exception_test.cpp b/test/defer_nested_success_exception_test.cpp
index efc7def..cdc7491 100644
--- a/test/defer_nested_success_exception_test.cpp
+++ b/test/defer_nested_success_exception_test.cpp
@@ -39,14 +39,14 @@ int main()
 		},
 		[ ]( info x )
 		{
-			BOOST_TEST(x.value==2);
+			BOOST_TEST_EQ(x.value, 2);
 			return 1;
 		},
 		[ ]
 		{
 			return 2;
 		 } );
-	BOOST_TEST(r==1);
+	BOOST_TEST_EQ(r, 1);
 
 	return boost::report_errors();
 }
diff --git a/test/defer_nested_success_result_test.cpp b/test/defer_nested_success_result_test.cpp
index cb3286d..9f22d24 100644
--- a/test/defer_nested_success_result_test.cpp
+++ b/test/defer_nested_success_result_test.cpp
@@ -41,14 +41,14 @@ int main()
 		},
 		[ ]( info x )
 		{
-			BOOST_TEST(x.value==2);
+			BOOST_TEST_EQ(x.value, 2);
 			return 2;
 		},
 		[ ]
 		{
 			return 3;
 		 } );
-	BOOST_TEST(r==2);
+	BOOST_TEST_EQ(r, 2);
 
 	return boost::report_errors();
 }
diff --git a/test/diagnostic_info_test.cpp b/test/diagnostic_info_test.cpp
index 30f1aef..5333e87 100644
--- a/test/diagnostic_info_test.cpp
+++ b/test/diagnostic_info_test.cpp
@@ -103,7 +103,7 @@ int main()
 			BOOST_TEST(s.find("*** printable_info_non_printable_payload ***")!=s.npos);
 			BOOST_TEST(s.find("*** printable_info_printable_payload printed printable_payload ***")!=s.npos);
 			BOOST_TEST(s.find(") in function")!=s.npos);
-			BOOST_TEST(s.find("unexpected")==s.npos);
+			BOOST_TEST_EQ(s.find("unexpected"), s.npos);
 			std::cout << s;
 		} );
 
@@ -142,7 +142,7 @@ int main()
 			BOOST_TEST(s.find(") in function")!=s.npos);
 			BOOST_TEST(s.find("Detected 2 attempts")!=s.npos);
 			BOOST_TEST(s.find("unexpected_test<1>")!=s.npos);
-			BOOST_TEST(s.find("unexpected_test<2>")==s.npos);
+			BOOST_TEST_EQ(s.find("unexpected_test<2>"), s.npos);
 			std::cout << s;
 		} );
 
diff --git a/test/exception_to_result_test.cpp b/test/exception_to_result_test.cpp
index b6040d2..590aa4c 100644
--- a/test/exception_to_result_test.cpp
+++ b/test/exception_to_result_test.cpp
@@ -37,7 +37,7 @@ int main()
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==1);
+		BOOST_TEST_EQ(r, 1);
 	}
 	{
 		int r = leaf::handle_all(
@@ -61,7 +61,7 @@ int main()
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 	{
 		int r = leaf::handle_all(
@@ -85,7 +85,7 @@ int main()
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==1);
+		BOOST_TEST_EQ(r, 1);
 	}
 	return boost::report_errors();
 }
diff --git a/test/handle_all_other_result_test.cpp b/test/handle_all_other_result_test.cpp
index 998bd18..0db28b7 100644
--- a/test/handle_all_other_result_test.cpp
+++ b/test/handle_all_other_result_test.cpp
@@ -84,7 +84,7 @@ int main()
 			{
 				return -1;
 			} );
-		BOOST_TEST(r==42);
+		BOOST_TEST_EQ(r, 42);
 	}
 	{
 		int r = leaf::handle_all(
@@ -93,21 +93,21 @@ int main()
 				auto r = g(false);
 				BOOST_TEST(!r);
 				auto ec = r.error();
-				BOOST_TEST(ec.message()=="LEAF error, use with leaf::handle_some or leaf::handle_all.");
+				BOOST_TEST_EQ(ec.message(), "LEAF error, use with leaf::handle_some or leaf::handle_all.");
 				BOOST_TEST(!std::strcmp(ec.category().name(),"LEAF error, use with leaf::handle_some or leaf::handle_all."));
 				return r;
 			},
 			[ ]( info<42> const & x, std::error_code const & ec )
 			{
-				BOOST_TEST(x.value==42);
-				BOOST_TEST(ec==make_error_code(std::errc::no_such_file_or_directory));
+				BOOST_TEST_EQ(x.value, 42);
+				BOOST_TEST_EQ(ec, make_error_code(std::errc::no_such_file_or_directory));
 				return 1;
 			},
 			[ ]
 			{
 				return 2;
 			} );
-		BOOST_TEST(r==1);
+		BOOST_TEST_EQ(r, 1);
 	}
 	return boost::report_errors();
 }
diff --git a/test/handle_all_test.cpp b/test/handle_all_test.cpp
index b8ed401..8538098 100644
--- a/test/handle_all_test.cpp
+++ b/test/handle_all_test.cpp
@@ -55,10 +55,10 @@ int main()
 			},
 			[&c]
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			} );
-		BOOST_TEST(c==42);
+		BOOST_TEST_EQ(c, 42);
 	}
 
 	// void, handle_all (failure)
@@ -74,17 +74,17 @@ int main()
 			[&c]( error_code ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec==error_code::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			},
 			[&c]()
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			} );
-		BOOST_TEST(c==1);
+		BOOST_TEST_EQ(c, 1);
 	}
 
 	// void, handle_all (failure), match cond_x (single enum value)
@@ -99,23 +99,23 @@ int main()
 			},
 			[&c]( leaf::match<leaf::condition<cond_x>, cond_x::x11> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			},
 			[&c]( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
 			{
-				BOOST_TEST(ec.value()==make_error_code(errc_a::a0));
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(ec.value(), make_error_code(errc_a::a0));
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]()
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 	}
 
 	// void, handle_all (failure), match enum (single enum value)
@@ -130,23 +130,23 @@ int main()
 			},
 			[&c]( leaf::match<error_code,error_code::error2> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			},
 			[&c]( leaf::match<error_code,error_code::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==error_code::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]()
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 	}
 
 	// void, handle_all (failure), match enum (multiple enum values)
@@ -161,23 +161,23 @@ int main()
 			},
 			[&c]( leaf::match<error_code,error_code::error2> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			},
 			[&c]( leaf::match<error_code,error_code::error2,error_code::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==error_code::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]()
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 	}
 
 	// void, handle_all (failure), match value (single value)
@@ -192,23 +192,23 @@ int main()
 			},
 			[&c]( leaf::match<e_error_code,error_code::error2> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			},
 			[&c]( leaf::match<e_error_code,error_code::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==error_code::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]()
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 	}
 
 	// void, handle_all (failure), match value (multiple values)
@@ -223,23 +223,23 @@ int main()
 			},
 			[&c]( leaf::match<e_error_code,error_code::error2> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			},
 			[&c]( leaf::match<e_error_code,error_code::error2,error_code::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==error_code::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]()
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 	}
 
 	//////////////////////////////////////
@@ -256,7 +256,7 @@ int main()
 			{
 				return 1;
 			} );
-		BOOST_TEST(r==42);
+		BOOST_TEST_EQ(r, 42);
 	}
 
 	// int, handle_all (failure)
@@ -270,15 +270,15 @@ int main()
 			[ ]( error_code ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec==error_code::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 1;
 			},
 			[ ]
 			{
 				return 2;
 			} );
-		BOOST_TEST(r==1);
+		BOOST_TEST_EQ(r, 1);
 	}
 
 	// int, handle_all (failure), match cond_x (single enum value)
@@ -295,16 +295,16 @@ int main()
 			},
 			[ ]( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
 			{
-				BOOST_TEST(ec.value()==make_error_code(errc_a::a0));
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(ec.value(), make_error_code(errc_a::a0));
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			},
 			[ ]
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 
 	// int, handle_all (failure), match enum (single enum value)
@@ -322,15 +322,15 @@ int main()
 			[ ]( leaf::match<error_code,error_code::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==error_code::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			},
 			[ ]
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 
 	// int, handle_all (failure), match enum (multiple enum values)
@@ -348,15 +348,15 @@ int main()
 			[ ]( leaf::match<error_code,error_code::error2,error_code::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==error_code::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			},
 			[ ]
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 
 	// int, handle_all (failure), match value (single value)
@@ -374,15 +374,15 @@ int main()
 			[ ]( leaf::match<e_error_code,error_code::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==error_code::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			},
 			[ ]
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 
 	// int, handle_all (failure), match value (multiple values)
@@ -400,15 +400,15 @@ int main()
 			[ ]( leaf::match<e_error_code,error_code::error2,error_code::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==error_code::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			},
 			[ ]
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 
 	return boost::report_errors();
diff --git a/test/handle_basic_test.cpp b/test/handle_basic_test.cpp
index 736207b..4471470 100644
--- a/test/handle_basic_test.cpp
+++ b/test/handle_basic_test.cpp
@@ -79,8 +79,8 @@ leaf::result<void> handle_some_errors_void( int what_to_do )
 
 int main()
 {
-	BOOST_TEST(handle_some_errors(0).value()==42);
-	BOOST_TEST(handle_some_errors(1).value()==-42);
+	BOOST_TEST_EQ(handle_some_errors(0).value(), 42);
+	BOOST_TEST_EQ(handle_some_errors(1).value(), -42);
 	{
 		int r = leaf::handle_all(
 			[ ]() -> leaf::result<int>
@@ -97,13 +97,13 @@ int main()
 			{
 				return 2;
 			} );
-		BOOST_TEST(r==1);
+		BOOST_TEST_EQ(r, 1);
 	}
 
 	///////////////////////////
 
-	BOOST_TEST(handle_some_errors_float(0).value()==42.0f);
-	BOOST_TEST(handle_some_errors_float(2).value()==-42.0f);
+	BOOST_TEST_EQ(handle_some_errors_float(0).value(), 42.0f);
+	BOOST_TEST_EQ(handle_some_errors_float(2).value(), -42.0f);
 	{
 		int r = leaf::handle_all(
 			[ ]() -> leaf::result<int>
@@ -120,7 +120,7 @@ int main()
 			{
 				return 2;
 			} );
-		BOOST_TEST(r==1);
+		BOOST_TEST_EQ(r, 1);
 	}
 
 	///////////////////////////
@@ -142,7 +142,7 @@ int main()
 			{
 				return 2;
 			} );
-		BOOST_TEST(r==1);
+		BOOST_TEST_EQ(r, 1);
 	}
 
 	///////////////////////////
@@ -162,7 +162,7 @@ int main()
 			{
 				return 2;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 
 	return boost::report_errors();
diff --git a/test/handle_some_other_result_test.cpp b/test/handle_some_other_result_test.cpp
index a166663..b7dd3f4 100644
--- a/test/handle_some_other_result_test.cpp
+++ b/test/handle_some_other_result_test.cpp
@@ -37,7 +37,7 @@ int main()
 				return g(true);
 			} );
 		BOOST_TEST(r);
-		BOOST_TEST(r.value()==42);
+		BOOST_TEST_EQ(r.value(), 42);
 	}
 	{
 		int called = 0;
@@ -47,18 +47,18 @@ int main()
 				auto r = g(false);
 				BOOST_TEST(!r);
 				auto ec = r.error();
-				BOOST_TEST(ec.message()=="LEAF error, use with leaf::handle_some or leaf::handle_all.");
+				BOOST_TEST_EQ(ec.message(), "LEAF error, use with leaf::handle_some or leaf::handle_all.");
 				BOOST_TEST(!std::strcmp(ec.category().name(),"LEAF error, use with leaf::handle_some or leaf::handle_all."));
 				return r;
 			},
 			[&]( info<42> const & x, leaf::match<leaf::condition<cond_x>, cond_x::x00> ec )
 			{
 				called = 1;
-				BOOST_TEST(x.value==42);
+				BOOST_TEST_EQ(x.value, 42);
 				return ec.value();
 			} );
 		BOOST_TEST(!r);
-		BOOST_TEST(r.error() == make_error_code(errc_a::a0));
+		BOOST_TEST_EQ(r.error(), make_error_code(errc_a::a0));
 		BOOST_TEST(called);
 	}
 	return boost::report_errors();
diff --git a/test/handle_some_test.cpp b/test/handle_some_test.cpp
index 424e859..c0c349b 100644
--- a/test/handle_some_test.cpp
+++ b/test/handle_some_test.cpp
@@ -56,12 +56,12 @@ int main()
 			},
 			[&c]( leaf::error_info const & unmatched )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 				return unmatched.error();
 			} );
 		BOOST_TEST(r);
-		BOOST_TEST(c==42);
+		BOOST_TEST_EQ(c, 42);
 	}
 
 	// void, handle_some (failure, matched)
@@ -77,12 +77,12 @@ int main()
 			[&c]( not_error_code_enum ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec==not_error_code_enum::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			} );
-		BOOST_TEST(c==1);
+		BOOST_TEST_EQ(c, 1);
 		BOOST_TEST(r);
 	}
 
@@ -98,13 +98,13 @@ int main()
 			},
 			[&c]( leaf::match<leaf::condition<cond_x>,cond_x::x00> ec, info<1> const & x, info<2> const & y )
 			{
-				BOOST_TEST(ec.value()==make_error_code(errc_a::a0));
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(ec.value(), make_error_code(errc_a::a0));
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			} );
-		BOOST_TEST(c==1);
+		BOOST_TEST_EQ(c, 1);
 		BOOST_TEST(r);
 	}
 
@@ -120,18 +120,18 @@ int main()
 			},
 			[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error2> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			},
 			[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==not_error_code_enum::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 		BOOST_TEST(r);
 	}
 
@@ -147,18 +147,18 @@ int main()
 			},
 			[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error2> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			},
 			[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==not_error_code_enum::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 		BOOST_TEST(r);
 	}
 
@@ -174,18 +174,18 @@ int main()
 			},
 			[&c]( leaf::match<e_error_code,not_error_code_enum::error2> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			},
 			[&c]( leaf::match<e_error_code,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==not_error_code_enum::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 		BOOST_TEST(r);
 	}
 
@@ -201,18 +201,18 @@ int main()
 			},
 			[&c]( leaf::match<e_error_code,not_error_code_enum::error2> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			},
 			[&c]( leaf::match<e_error_code,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==not_error_code_enum::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 		BOOST_TEST(r);
 	}
 
@@ -231,27 +231,27 @@ int main()
 					},
 					[&c]( info<4> )
 					{
-						BOOST_TEST(c==0);
+						BOOST_TEST_EQ(c, 0);
 						c = 1;
 					} );
 				BOOST_TEST(!r);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				return r;
 			},
 			[&c]( not_error_code_enum ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec==not_error_code_enum::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]()
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 	}
 
 	// void, handle_some (failure, initially not matched), match cond_x (single enum value)
@@ -269,27 +269,27 @@ int main()
 					},
 					[&c]( leaf::match<leaf::condition<cond_x>, cond_x::x11> )
 					{
-						BOOST_TEST(c==0);
+						BOOST_TEST_EQ(c, 0);
 						c = 1;
 					} );
 				BOOST_TEST(!r);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				return r;
 			},
 			[&c]( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
 			{
-				BOOST_TEST(ec.value()==make_error_code(errc_a::a0));
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(ec.value(), make_error_code(errc_a::a0));
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]()
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 	}
 
 	// void, handle_some (failure, initially not matched), match enum (single enum value)
@@ -307,27 +307,27 @@ int main()
 					},
 					[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error2> )
 					{
-						BOOST_TEST(c==0);
+						BOOST_TEST_EQ(c, 0);
 						c = 1;
 					} );
 				BOOST_TEST(!r);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				return r;
 			},
 			[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==not_error_code_enum::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]()
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 	}
 
 	// void, handle_some (failure, initially not matched), match enum (multiple enum values)
@@ -345,27 +345,27 @@ int main()
 					},
 					[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error2> )
 					{
-						BOOST_TEST(c==0);
+						BOOST_TEST_EQ(c, 0);
 						c = 1;
 					} );
 				BOOST_TEST(!r);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				return r;
 			},
 			[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==not_error_code_enum::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]()
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 	}
 
 	// void, handle_some (failure, initially not matched), match value (single value)
@@ -383,27 +383,27 @@ int main()
 					},
 					[&c]( leaf::match<e_error_code,not_error_code_enum::error2> )
 					{
-						BOOST_TEST(c==0);
+						BOOST_TEST_EQ(c, 0);
 						c = 1;
 					} );
 				BOOST_TEST(!r);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				return r;
 			},
 			[&c]( leaf::match<e_error_code,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==not_error_code_enum::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]()
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 	}
 
 	// void, handle_some (failure, initially not matched), match value (multiple values)
@@ -421,27 +421,27 @@ int main()
 					},
 					[&c]( leaf::match<e_error_code,not_error_code_enum::error2> )
 					{
-						BOOST_TEST(c==0);
+						BOOST_TEST_EQ(c, 0);
 						c = 1;
 					} );
 				BOOST_TEST(!r);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				return r;
 			},
 			[&c]( leaf::match<e_error_code,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==not_error_code_enum::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]()
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 	}
 
 	// void, handle_some (failure, initially matched)
@@ -460,26 +460,26 @@ int main()
 					[&c]( not_error_code_enum ec, info<1> const & x, info<2> y )
 					{
 						BOOST_TEST(ec==not_error_code_enum::error1);
-						BOOST_TEST(x.value==1);
-						BOOST_TEST(y.value==2);
-						BOOST_TEST(c==0);
+						BOOST_TEST_EQ(x.value, 1);
+						BOOST_TEST_EQ(y.value, 2);
+						BOOST_TEST_EQ(c, 0);
 						c = 1;
 					} );
 				BOOST_TEST(r);
-				BOOST_TEST(c==1);
+				BOOST_TEST_EQ(c, 1);
 				return r;
 			},
 			[&c]( info<4> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]()
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==1);
+		BOOST_TEST_EQ(c, 1);
 	}
 
 	// void, handle_some (failure, initially matched), match cond_x (single enum value)
@@ -497,27 +497,27 @@ int main()
 					},
 					[&c]( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
 					{
-						BOOST_TEST(ec.value()==make_error_code(errc_a::a0));
-						BOOST_TEST(x.value==1);
-						BOOST_TEST(y.value==2);
-						BOOST_TEST(c==0);
+						BOOST_TEST_EQ(ec.value(), make_error_code(errc_a::a0));
+						BOOST_TEST_EQ(x.value, 1);
+						BOOST_TEST_EQ(y.value, 2);
+						BOOST_TEST_EQ(c, 0);
 						c = 1;
 					} );
 				BOOST_TEST(r);
-				BOOST_TEST(c==1);
+				BOOST_TEST_EQ(c, 1);
 				return r;
 			},
 			[&c]( leaf::match<leaf::condition<cond_x>, cond_x::x11> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]()
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==1);
+		BOOST_TEST_EQ(c, 1);
 	}
 
 	// void, handle_some (failure, initially matched), match enum (single enum value)
@@ -536,26 +536,26 @@ int main()
 					[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 					{
 						BOOST_TEST(ec.value()==not_error_code_enum::error1);
-						BOOST_TEST(x.value==1);
-						BOOST_TEST(y.value==2);
-						BOOST_TEST(c==0);
+						BOOST_TEST_EQ(x.value, 1);
+						BOOST_TEST_EQ(y.value, 2);
+						BOOST_TEST_EQ(c, 0);
 						c = 1;
 					} );
 				BOOST_TEST(r);
-				BOOST_TEST(c==1);
+				BOOST_TEST_EQ(c, 1);
 				return r;
 			},
 			[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error2> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]()
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==1);
+		BOOST_TEST_EQ(c, 1);
 	}
 
 	// void, handle_some (failure, initially matched), match enum (multiple enum values)
@@ -574,26 +574,26 @@ int main()
 					[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 					{
 						BOOST_TEST(ec.value()==not_error_code_enum::error1);
-						BOOST_TEST(x.value==1);
-						BOOST_TEST(y.value==2);
-						BOOST_TEST(c==0);
+						BOOST_TEST_EQ(x.value, 1);
+						BOOST_TEST_EQ(y.value, 2);
+						BOOST_TEST_EQ(c, 0);
 						c = 1;
 					} );
 				BOOST_TEST(r);
-				BOOST_TEST(c==1);
+				BOOST_TEST_EQ(c, 1);
 				return r;
 			},
 			[&c]( leaf::match<not_error_code_enum,not_error_code_enum::error2> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]()
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==1);
+		BOOST_TEST_EQ(c, 1);
 	}
 
 	// void, handle_some (failure, initially matched), match value (single value)
@@ -612,26 +612,26 @@ int main()
 					[&c]( leaf::match<e_error_code,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 					{
 						BOOST_TEST(ec.value()==not_error_code_enum::error1);
-						BOOST_TEST(x.value==1);
-						BOOST_TEST(y.value==2);
-						BOOST_TEST(c==0);
+						BOOST_TEST_EQ(x.value, 1);
+						BOOST_TEST_EQ(y.value, 2);
+						BOOST_TEST_EQ(c, 0);
 						c = 1;
 					} );
 				BOOST_TEST(r);
-				BOOST_TEST(c==1);
+				BOOST_TEST_EQ(c, 1);
 				return r;
 			},
 			[&c]( leaf::match<e_error_code,not_error_code_enum::error2> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]()
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==1);
+		BOOST_TEST_EQ(c, 1);
 	}
 
 	// void, handle_some (failure, initially matched), match value (multiple values)
@@ -650,26 +650,26 @@ int main()
 					[&c]( leaf::match<e_error_code,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 					{
 						BOOST_TEST(ec.value()==not_error_code_enum::error1);
-						BOOST_TEST(x.value==1);
-						BOOST_TEST(y.value==2);
-						BOOST_TEST(c==0);
+						BOOST_TEST_EQ(x.value, 1);
+						BOOST_TEST_EQ(y.value, 2);
+						BOOST_TEST_EQ(c, 0);
 						c = 1;
 					} );
 				BOOST_TEST(r);
-				BOOST_TEST(c==1);
+				BOOST_TEST_EQ(c, 1);
 				return r;
 			},
 			[&c]( leaf::match<e_error_code,not_error_code_enum::error2> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]()
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==1);
+		BOOST_TEST_EQ(c, 1);
 	}
 
 	//////////////////////////////////////
@@ -686,7 +686,7 @@ int main()
 			{
 				return unmatched.error();
 			} );
-		BOOST_TEST(r && *r==42);
+		BOOST_TEST_EQ(*r, 42);
 	}
 
 	// int, handle_some (failure, matched)
@@ -700,11 +700,12 @@ int main()
 			[ ]( not_error_code_enum ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec==not_error_code_enum::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 1;
 			} );
-		BOOST_TEST(r && *r==1);
+		BOOST_TEST(r);
+		BOOST_TEST_EQ(*r, 1);
 	}
 
 	// int, handle_some (failure, matched), match cond_x (single enum value)
@@ -721,12 +722,13 @@ int main()
 			},
 			[ ]( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
 			{
-				BOOST_TEST(ec.value()==make_error_code(errc_a::a0));
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(ec.value(), make_error_code(errc_a::a0));
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			} );
-		BOOST_TEST(r && *r==2);
+		BOOST_TEST(r);
+		BOOST_TEST_EQ(*r, 2);
 	}
 
 	// int, handle_some (failure, matched), match enum (single enum value)
@@ -744,11 +746,12 @@ int main()
 			[ ]( leaf::match<not_error_code_enum,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==not_error_code_enum::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			} );
-		BOOST_TEST(r && *r==2);
+		BOOST_TEST(r);
+		BOOST_TEST_EQ(*r, 2);
 	}
 
 	// int, handle_some (failure, matched), match enum (multiple enum values)
@@ -766,11 +769,12 @@ int main()
 			[ ]( leaf::match<not_error_code_enum,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==not_error_code_enum::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			} );
-		BOOST_TEST(r && *r==2);
+		BOOST_TEST(r);
+		BOOST_TEST_EQ(*r, 2);
 	}
 
 	// int, handle_some (failure, matched), match value (single value)
@@ -788,11 +792,12 @@ int main()
 			[ ]( leaf::match<e_error_code,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==not_error_code_enum::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			} );
-		BOOST_TEST(r && *r==2);
+		BOOST_TEST(r);
+		BOOST_TEST_EQ(*r, 2);
 	}
 
 	// int, handle_some (failure, matched), match value (multiple values)
@@ -810,11 +815,12 @@ int main()
 			[ ]( leaf::match<e_error_code,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==not_error_code_enum::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			} );
-		BOOST_TEST(r && *r==2);
+		BOOST_TEST(r);
+		BOOST_TEST_EQ(*r, 2);
 	}
 
 	// int, handle_some (failure, initially not matched)
@@ -838,15 +844,15 @@ int main()
 			[ ]( not_error_code_enum ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec==not_error_code_enum::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			},
 			[ ]
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 
 	// int, handle_some (failure, initially not matched), match cond_x (single enum value)
@@ -869,16 +875,16 @@ int main()
 			},
 			[ ]( leaf::match<leaf::condition<cond_x>, cond_x::x00> ec, info<1> const & x, info<2> y )
 			{
-				BOOST_TEST(ec.value()==make_error_code(errc_a::a0));
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(ec.value(), make_error_code(errc_a::a0));
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			},
 			[ ]
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 
 	// int, handle_some (failure, initially not matched), match enum (single enum value)
@@ -902,15 +908,15 @@ int main()
 			[ ]( leaf::match<not_error_code_enum,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==not_error_code_enum::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			},
 			[ ]
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 
 	// int, handle_some (failure, initially not matched), match enum (multiple enum values)
@@ -934,15 +940,15 @@ int main()
 			[ ]( leaf::match<not_error_code_enum,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==not_error_code_enum::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			},
 			[ ]
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 
 	// int, handle_some (failure, initially not matched), match value (single value)
@@ -966,15 +972,15 @@ int main()
 			[ ]( leaf::match<e_error_code,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==not_error_code_enum::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			},
 			[ ]
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 
 	// int, handle_some (failure, initially not matched), match value (multiple values)
@@ -998,15 +1004,15 @@ int main()
 			[ ]( leaf::match<e_error_code,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 			{
 				BOOST_TEST(ec.value()==not_error_code_enum::error1);
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			},
 			[ ]
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 
 	// int, handle_some (failure, initially matched)
@@ -1023,8 +1029,8 @@ int main()
 					[ ]( not_error_code_enum ec, info<1> const & x, info<2> y )
 					{
 						BOOST_TEST(ec==not_error_code_enum::error1);
-						BOOST_TEST(x.value==1);
-						BOOST_TEST(y.value==2);
+						BOOST_TEST_EQ(x.value, 1);
+						BOOST_TEST_EQ(y.value, 2);
 						return 1;
 					} );
 				BOOST_TEST(r);
@@ -1038,7 +1044,7 @@ int main()
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==1);
+		BOOST_TEST_EQ(r, 1);
 	}
 
 	// int, handle_some (failure, initially matched), match enum (single enum value)
@@ -1055,8 +1061,8 @@ int main()
 					[ ]( leaf::match<not_error_code_enum,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 					{
 						BOOST_TEST(ec.value()==not_error_code_enum::error1);
-						BOOST_TEST(x.value==1);
-						BOOST_TEST(y.value==2);
+						BOOST_TEST_EQ(x.value, 1);
+						BOOST_TEST_EQ(y.value, 2);
 						return 1;
 					} );
 				BOOST_TEST(r);
@@ -1070,7 +1076,7 @@ int main()
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==1);
+		BOOST_TEST_EQ(r, 1);
 	}
 
 	// int, handle_some (failure, initially matched), match enum (multiple enum values)
@@ -1087,8 +1093,8 @@ int main()
 					[ ]( leaf::match<not_error_code_enum,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 					{
 						BOOST_TEST(ec.value()==not_error_code_enum::error1);
-						BOOST_TEST(x.value==1);
-						BOOST_TEST(y.value==2);
+						BOOST_TEST_EQ(x.value, 1);
+						BOOST_TEST_EQ(y.value, 2);
 						return 1;
 					} );
 				BOOST_TEST(r);
@@ -1102,7 +1108,7 @@ int main()
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==1);
+		BOOST_TEST_EQ(r, 1);
 	}
 
 	// int, handle_some (failure, initially matched), match value (single value)
@@ -1119,8 +1125,8 @@ int main()
 					[ ]( leaf::match<e_error_code,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 					{
 						BOOST_TEST(ec.value()==not_error_code_enum::error1);
-						BOOST_TEST(x.value==1);
-						BOOST_TEST(y.value==2);
+						BOOST_TEST_EQ(x.value, 1);
+						BOOST_TEST_EQ(y.value, 2);
 						return 1;
 					} );
 				BOOST_TEST(r);
@@ -1134,7 +1140,7 @@ int main()
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==1);
+		BOOST_TEST_EQ(r, 1);
 	}
 
 	// int, handle_some (failure, initially matched), match value (multiple values)
@@ -1151,8 +1157,8 @@ int main()
 					[ ]( leaf::match<e_error_code,not_error_code_enum::error2,not_error_code_enum::error1> ec, info<1> const & x, info<2> y )
 					{
 						BOOST_TEST(ec.value()==not_error_code_enum::error1);
-						BOOST_TEST(x.value==1);
-						BOOST_TEST(y.value==2);
+						BOOST_TEST_EQ(x.value, 1);
+						BOOST_TEST_EQ(y.value, 2);
 						return 1;
 					} );
 				BOOST_TEST(r);
@@ -1166,7 +1172,7 @@ int main()
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==1);
+		BOOST_TEST_EQ(r, 1);
 	}
 
 	return boost::report_errors();
diff --git a/test/multiple_errors_test.cpp b/test/multiple_errors_test.cpp
index ae0f4f6..2698719 100644
--- a/test/multiple_errors_test.cpp
+++ b/test/multiple_errors_test.cpp
@@ -42,14 +42,14 @@ int main()
 		},
 		[ ]( info<2> const & x, info<3> const & y )
 		{
-			BOOST_TEST(x.value==2);
-			BOOST_TEST(y.value==3);
+			BOOST_TEST_EQ(x.value, 2);
+			BOOST_TEST_EQ(y.value, 3);
 			return 2;
 		},
 		[ ]
 		{
 			return 3;
 		} );
-	BOOST_TEST(r==2);
+	BOOST_TEST_EQ(r, 2);
 	return boost::report_errors();
 }
diff --git a/test/optional_test.cpp b/test/optional_test.cpp
index c0ff0a9..0ffbc97 100644
--- a/test/optional_test.cpp
+++ b/test/optional_test.cpp
@@ -88,19 +88,19 @@ void run_tests()
 	BOOST_TEST(!value_count);
 	{
 		my_info a(42);
-		BOOST_TEST(object_count==1);
-		BOOST_TEST(value_count==1);
+		BOOST_TEST_EQ(object_count, 1);
+		BOOST_TEST_EQ(value_count, 1);
 		optional<my_info> x(a);
-		BOOST_TEST(object_count==2);
-		BOOST_TEST(value_count==2);
+		BOOST_TEST_EQ(object_count, 2);
+		BOOST_TEST_EQ(value_count, 2);
 		BOOST_TEST(x.has_value());
-		BOOST_TEST(x.value().value==42);
+		BOOST_TEST_EQ(x.value().value, 42);
 	}
 	BOOST_TEST(!object_count);
 	BOOST_TEST(!value_count);
 	{
 		throws_on_copy a;
-		BOOST_TEST(object_count==1);
+		BOOST_TEST_EQ(object_count, 1);
 		try
 		{
 			optional<throws_on_copy> x(a);
@@ -114,86 +114,86 @@ void run_tests()
 	BOOST_TEST(!value_count);
 	{
 		my_info a(42);
-		BOOST_TEST(object_count==1);
-		BOOST_TEST(value_count==1);
+		BOOST_TEST_EQ(object_count, 1);
+		BOOST_TEST_EQ(value_count, 1);
 		optional<my_info> x(std::move(a));
-		BOOST_TEST(object_count==2);
-		BOOST_TEST(value_count==1);
+		BOOST_TEST_EQ(object_count, 2);
+		BOOST_TEST_EQ(value_count, 1);
 		BOOST_TEST(x.has_value());
-		BOOST_TEST(x.value().value==42);
+		BOOST_TEST_EQ(x.value().value, 42);
 	}
 	BOOST_TEST(!object_count);
 	BOOST_TEST(!value_count);
 	{
 		optional<my_info> x(my_info(42));
-		BOOST_TEST(object_count==1);
-		BOOST_TEST(value_count==1);
+		BOOST_TEST_EQ(object_count, 1);
+		BOOST_TEST_EQ(value_count, 1);
 		BOOST_TEST(x.has_value());
-		BOOST_TEST(x.value().value==42);
+		BOOST_TEST_EQ(x.value().value, 42);
 		optional<my_info> y(x);
-		BOOST_TEST(object_count==2);
-		BOOST_TEST(value_count==2);
+		BOOST_TEST_EQ(object_count, 2);
+		BOOST_TEST_EQ(value_count, 2);
 		BOOST_TEST(x.has_value());
-		BOOST_TEST(x.value().value==42);
+		BOOST_TEST_EQ(x.value().value, 42);
 		BOOST_TEST(y.has_value());
-		BOOST_TEST(y.value().value==42);
+		BOOST_TEST_EQ(y.value().value, 42);
 	}
 	BOOST_TEST(!object_count);
 	BOOST_TEST(!value_count);
 	{
 		optional<my_info> x(my_info(42));
-		BOOST_TEST(object_count==1);
-		BOOST_TEST(value_count==1);
+		BOOST_TEST_EQ(object_count, 1);
+		BOOST_TEST_EQ(value_count, 1);
 		BOOST_TEST(x.has_value());
-		BOOST_TEST(x.value().value==42);
+		BOOST_TEST_EQ(x.value().value, 42);
 		optional<my_info> y(std::move(x));
-		BOOST_TEST(object_count==1);
-		BOOST_TEST(value_count==1);
+		BOOST_TEST_EQ(object_count, 1);
+		BOOST_TEST_EQ(value_count, 1);
 		BOOST_TEST(!x.has_value());
 		BOOST_TEST(y.has_value());
-		BOOST_TEST(y.value().value==42);
+		BOOST_TEST_EQ(y.value().value, 42);
 	}
 	BOOST_TEST(!object_count);
 	BOOST_TEST(!value_count);
 	{
 		optional<my_info> x(my_info(42));
-		BOOST_TEST(object_count==1);
-		BOOST_TEST(value_count==1);
+		BOOST_TEST_EQ(object_count, 1);
+		BOOST_TEST_EQ(value_count, 1);
 		BOOST_TEST(x.has_value());
-		BOOST_TEST(x.value().value==42);
+		BOOST_TEST_EQ(x.value().value, 42);
 		optional<my_info> y;
-		BOOST_TEST(&(y=x)==&y);
-		BOOST_TEST(object_count==2);
-		BOOST_TEST(value_count==2);
+		BOOST_TEST_EQ(&(y=x), &y);
+		BOOST_TEST_EQ(object_count, 2);
+		BOOST_TEST_EQ(value_count, 2);
 		BOOST_TEST(x.has_value());
-		BOOST_TEST(x.value().value==42);
+		BOOST_TEST_EQ(x.value().value, 42);
 		BOOST_TEST(y.has_value());
-		BOOST_TEST(y.value().value==42);
+		BOOST_TEST_EQ(y.value().value, 42);
 	}
 	BOOST_TEST(!object_count);
 	BOOST_TEST(!value_count);
 	{
 		optional<my_info> x(my_info(42));
-		BOOST_TEST(object_count==1);
-		BOOST_TEST(value_count==1);
+		BOOST_TEST_EQ(object_count, 1);
+		BOOST_TEST_EQ(value_count, 1);
 		BOOST_TEST(x.has_value());
-		BOOST_TEST(x.value().value==42);
+		BOOST_TEST_EQ(x.value().value, 42);
 		optional<my_info> y(my_info(43));
-		BOOST_TEST(object_count==2);
-		BOOST_TEST(value_count==2);
-		BOOST_TEST(&(y=x)==&y);
-		BOOST_TEST(object_count==2);
-		BOOST_TEST(value_count==2);
+		BOOST_TEST_EQ(object_count, 2);
+		BOOST_TEST_EQ(value_count, 2);
+		BOOST_TEST_EQ(&(y=x), &y);
+		BOOST_TEST_EQ(object_count, 2);
+		BOOST_TEST_EQ(value_count, 2);
 		BOOST_TEST(x.has_value());
-		BOOST_TEST(x.value().value==42);
+		BOOST_TEST_EQ(x.value().value, 42);
 		BOOST_TEST(y.has_value());
-		BOOST_TEST(y.value().value==42);
+		BOOST_TEST_EQ(y.value().value, 42);
 	}
 	BOOST_TEST(!object_count);
 	BOOST_TEST(!value_count);
 	{
 		optional<throws_on_copy> x((throws_on_copy()));
-		BOOST_TEST(object_count==1);
+		BOOST_TEST_EQ(object_count, 1);
 		BOOST_TEST(x.has_value());
 		optional<throws_on_copy> y;
 		try
@@ -203,7 +203,7 @@ void run_tests()
 		catch( std::exception & )
 		{
 		}
-		BOOST_TEST(object_count==1);
+		BOOST_TEST_EQ(object_count, 1);
 		BOOST_TEST(x.has_value());
 		BOOST_TEST(!y.has_value());
 	}
@@ -211,35 +211,35 @@ void run_tests()
 	BOOST_TEST(!value_count);
 	{
 		optional<my_info> x(my_info(42));
-		BOOST_TEST(object_count==1);
-		BOOST_TEST(value_count==1);
+		BOOST_TEST_EQ(object_count, 1);
+		BOOST_TEST_EQ(value_count, 1);
 		BOOST_TEST(x.has_value());
-		BOOST_TEST(x.value().value==42);
+		BOOST_TEST_EQ(x.value().value, 42);
 		optional<my_info> y;
-		BOOST_TEST(&(y=std::move(x))==&y);
-		BOOST_TEST(object_count==1);
-		BOOST_TEST(value_count==1);
+		BOOST_TEST_EQ(&(y=std::move(x)), &y);
+		BOOST_TEST_EQ(object_count, 1);
+		BOOST_TEST_EQ(value_count, 1);
 		BOOST_TEST(!x.has_value());
 		BOOST_TEST(y.has_value());
-		BOOST_TEST(y.value().value==42);
+		BOOST_TEST_EQ(y.value().value, 42);
 	}
 	BOOST_TEST(!object_count);
 	BOOST_TEST(!value_count);
 	{
 		optional<my_info> x(my_info(42));
-		BOOST_TEST(object_count==1);
-		BOOST_TEST(value_count==1);
+		BOOST_TEST_EQ(object_count, 1);
+		BOOST_TEST_EQ(value_count, 1);
 		BOOST_TEST(x.has_value());
-		BOOST_TEST(x.value().value==42);
+		BOOST_TEST_EQ(x.value().value, 42);
 		optional<my_info> y(my_info(43));
-		BOOST_TEST(object_count==2);
-		BOOST_TEST(value_count==2);
-		BOOST_TEST(&(y=std::move(x))==&y);
-		BOOST_TEST(object_count==1);
-		BOOST_TEST(value_count==1);
+		BOOST_TEST_EQ(object_count, 2);
+		BOOST_TEST_EQ(value_count, 2);
+		BOOST_TEST_EQ(&(y=std::move(x)), &y);
+		BOOST_TEST_EQ(object_count, 1);
+		BOOST_TEST_EQ(value_count, 1);
 		BOOST_TEST(!x.has_value());
 		BOOST_TEST(y.has_value());
-		BOOST_TEST(y.value().value==42);
+		BOOST_TEST_EQ(y.value().value, 42);
 	}
 	BOOST_TEST(!object_count);
 	BOOST_TEST(!value_count);
@@ -247,64 +247,64 @@ void run_tests()
 		optional<my_info> x;
 		my_info a(42);
 		x.put(a);
-		BOOST_TEST(object_count==2);
-		BOOST_TEST(value_count==2);
+		BOOST_TEST_EQ(object_count, 2);
+		BOOST_TEST_EQ(value_count, 2);
 		BOOST_TEST(x.has_value());
-		BOOST_TEST(x.value().value==42);
+		BOOST_TEST_EQ(x.value().value, 42);
 	}
 	BOOST_TEST(!object_count);
 	BOOST_TEST(!value_count);
 	{
 		optional<my_info> x(my_info(43));
-		BOOST_TEST(object_count==1);
-		BOOST_TEST(value_count==1);
+		BOOST_TEST_EQ(object_count, 1);
+		BOOST_TEST_EQ(value_count, 1);
 		my_info a(42);
 		x.put(a);
-		BOOST_TEST(object_count==2);
-		BOOST_TEST(value_count==2);
+		BOOST_TEST_EQ(object_count, 2);
+		BOOST_TEST_EQ(value_count, 2);
 		BOOST_TEST(x.has_value());
-		BOOST_TEST(x.value().value==42);
+		BOOST_TEST_EQ(x.value().value, 42);
 	}
 	BOOST_TEST(!object_count);
 	BOOST_TEST(!value_count);
 	{
 		optional<my_info> x;
 		x.put(my_info(42));
-		BOOST_TEST(object_count==1);
-		BOOST_TEST(value_count==1);
+		BOOST_TEST_EQ(object_count, 1);
+		BOOST_TEST_EQ(value_count, 1);
 		BOOST_TEST(x.has_value());
-		BOOST_TEST(x.value().value==42);
+		BOOST_TEST_EQ(x.value().value, 42);
 	}
 	BOOST_TEST(!object_count);
 	BOOST_TEST(!value_count);
 	{
 		optional<my_info> x(my_info(43));
-		BOOST_TEST(object_count==1);
-		BOOST_TEST(value_count==1);
+		BOOST_TEST_EQ(object_count, 1);
+		BOOST_TEST_EQ(value_count, 1);
 		x.put(my_info(42));
-		BOOST_TEST(object_count==1);
-		BOOST_TEST(value_count==1);
+		BOOST_TEST_EQ(object_count, 1);
+		BOOST_TEST_EQ(value_count, 1);
 		BOOST_TEST(x.has_value());
-		BOOST_TEST(x.value().value==42);
+		BOOST_TEST_EQ(x.value().value, 42);
 	}
 	BOOST_TEST(!object_count);
 	BOOST_TEST(!value_count);
 	{
 		optional<my_info> x(my_info(42));
-		BOOST_TEST(object_count==1);
-		BOOST_TEST(value_count==1);
+		BOOST_TEST_EQ(object_count, 1);
+		BOOST_TEST_EQ(value_count, 1);
 		my_info a = std::move(x).value();
-		BOOST_TEST(object_count==1);
-		BOOST_TEST(value_count==1);
+		BOOST_TEST_EQ(object_count, 1);
+		BOOST_TEST_EQ(value_count, 1);
 		BOOST_TEST(!x.has_value());
-		BOOST_TEST(a.value==42);
+		BOOST_TEST_EQ(a.value, 42);
 	}
 	BOOST_TEST(!object_count);
 	BOOST_TEST(!value_count);
 	{
 		optional<my_info> x(my_info(42));
-		BOOST_TEST(object_count==1);
-		BOOST_TEST(value_count==1);
+		BOOST_TEST_EQ(object_count, 1);
+		BOOST_TEST_EQ(value_count, 1);
 		BOOST_TEST(x.has_value());
 		x.reset();
 		BOOST_TEST(!x.has_value());
diff --git a/test/preload_basic_test.cpp b/test/preload_basic_test.cpp
index 7eb4950..adfeb54 100644
--- a/test/preload_basic_test.cpp
+++ b/test/preload_basic_test.cpp
@@ -36,13 +36,13 @@ int main()
 		},
 		[ ]( info const & i42 )
 		{
-			BOOST_TEST(i42.value==42);
+			BOOST_TEST_EQ(i42.value, 42);
 			return 1;
 		},
 		[ ]
 		{
 			return 2;
 		} );
-	BOOST_TEST(r==1);
+	BOOST_TEST_EQ(r, 1);
 	return boost::report_errors();
 }
diff --git a/test/preload_nested_error_exception_test.cpp b/test/preload_nested_error_exception_test.cpp
index 2301549..3c89e06 100644
--- a/test/preload_nested_error_exception_test.cpp
+++ b/test/preload_nested_error_exception_test.cpp
@@ -52,17 +52,17 @@ int main()
 		},
 		[ ]( info<0> i0, info<1> i1, info<2> i2, info<3> i3 )
 		{
-			BOOST_TEST(i0.value==0);
-			BOOST_TEST(i1.value==1);
-			BOOST_TEST(i2.value==2);
-			BOOST_TEST(i3.value==3);
+			BOOST_TEST_EQ(i0.value, 0);
+			BOOST_TEST_EQ(i1.value, 1);
+			BOOST_TEST_EQ(i2.value, 2);
+			BOOST_TEST_EQ(i3.value, 3);
 			return 1;
 		},
 		[ ]
 		{
 			return 2;
 		} );
-	BOOST_TEST(r==1);
+	BOOST_TEST_EQ(r, 1);
 
 	return boost::report_errors();
 }
diff --git a/test/preload_nested_error_result_test.cpp b/test/preload_nested_error_result_test.cpp
index afef861..205efd3 100644
--- a/test/preload_nested_error_result_test.cpp
+++ b/test/preload_nested_error_result_test.cpp
@@ -43,17 +43,17 @@ int main()
 		},
 		[ ]( info<0> i0, info<1> i1, info<2> i2, info<3> i3 )
 		{
-			BOOST_TEST(i0.value==0);
-			BOOST_TEST(i1.value==1);
-			BOOST_TEST(i2.value==2);
-			BOOST_TEST(i3.value==3);
+			BOOST_TEST_EQ(i0.value, 0);
+			BOOST_TEST_EQ(i1.value, 1);
+			BOOST_TEST_EQ(i2.value, 2);
+			BOOST_TEST_EQ(i3.value, 3);
 			return 1;
 		},
 		[ ]
 		{
 			return 2;
 		} );
-	BOOST_TEST(r==1);
+	BOOST_TEST_EQ(r, 1);
 
 	return boost::report_errors();
 }
diff --git a/test/preload_nested_new_error_exception_test.cpp b/test/preload_nested_new_error_exception_test.cpp
index 248d2b7..f41bc6f 100644
--- a/test/preload_nested_new_error_exception_test.cpp
+++ b/test/preload_nested_new_error_exception_test.cpp
@@ -59,17 +59,17 @@ int main()
 		},
 		[ ]( info<0> i0, info<1> i1, info<2> i2, info<3> i3 )
 		{
-			BOOST_TEST(i0.value==0);
-			BOOST_TEST(i1.value==1);
-			BOOST_TEST(i2.value==2);
-			BOOST_TEST(i3.value==3);
+			BOOST_TEST_EQ(i0.value, 0);
+			BOOST_TEST_EQ(i1.value, 1);
+			BOOST_TEST_EQ(i2.value, 2);
+			BOOST_TEST_EQ(i3.value, 3);
 			return 1;
 		},
 		[ ]
 		{
 			return 2;
 		} );
-	BOOST_TEST(r==1);
+	BOOST_TEST_EQ(r, 1);
 
 	return boost::report_errors();
 }
diff --git a/test/preload_nested_new_error_result_test.cpp b/test/preload_nested_new_error_result_test.cpp
index 9a2b70e..74ef96a 100644
--- a/test/preload_nested_new_error_result_test.cpp
+++ b/test/preload_nested_new_error_result_test.cpp
@@ -44,17 +44,17 @@ int main()
 		},
 		[ ]( info<0> i0, info<1> i1, info<2> i2, info<3> i3 )
 		{
-			BOOST_TEST(i0.value==0);
-			BOOST_TEST(i1.value==1);
-			BOOST_TEST(i2.value==2);
-			BOOST_TEST(i3.value==3);
+			BOOST_TEST_EQ(i0.value, 0);
+			BOOST_TEST_EQ(i1.value, 1);
+			BOOST_TEST_EQ(i2.value, 2);
+			BOOST_TEST_EQ(i3.value, 3);
 			return 1;
 		},
 		[ ]
 		{
 			return 2;
 		} );
-	BOOST_TEST(r==1);
+	BOOST_TEST_EQ(r, 1);
 
 	return boost::report_errors();
 }
diff --git a/test/preload_nested_success_exception_test.cpp b/test/preload_nested_success_exception_test.cpp
index 03ba617..7ac9268 100644
--- a/test/preload_nested_success_exception_test.cpp
+++ b/test/preload_nested_success_exception_test.cpp
@@ -39,14 +39,14 @@ int main()
 		},
 		[ ]( info x )
 		{
-			BOOST_TEST(x.value==2);
+			BOOST_TEST_EQ(x.value, 2);
 			return 1;
 		},
 		[ ]
 		{
 			return 2;
 		 } );
-	BOOST_TEST(r==1);
+	BOOST_TEST_EQ(r, 1);
 
 	return boost::report_errors();
 }
diff --git a/test/preload_nested_success_result_test.cpp b/test/preload_nested_success_result_test.cpp
index d0ff1fc..b46c0c4 100644
--- a/test/preload_nested_success_result_test.cpp
+++ b/test/preload_nested_success_result_test.cpp
@@ -41,14 +41,14 @@ int main()
 		},
 		[ ]( info x )
 		{
-			BOOST_TEST(x.value==2);
+			BOOST_TEST_EQ(x.value, 2);
 			return 2;
 		},
 		[ ]
 		{
 			return 3;
 		 } );
-	BOOST_TEST(r==2);
+	BOOST_TEST_EQ(r, 2);
 
 	return boost::report_errors();
 }
diff --git a/test/result_bad_result_test.cpp b/test/result_bad_result_test.cpp
index 287fae2..5c3728b 100644
--- a/test/result_bad_result_test.cpp
+++ b/test/result_bad_result_test.cpp
@@ -29,7 +29,7 @@ int main()
 				return 0;
 			},
 			check );
-		BOOST_TEST(r==1);
+		BOOST_TEST_EQ(r, 1);
 	}
 	{
 		int r = leaf::try_(
@@ -40,7 +40,7 @@ int main()
 				return 0;
 			},
 			check );
-		BOOST_TEST(r==1);
+		BOOST_TEST_EQ(r, 1);
 	}
 	{
 		int r = leaf::try_(
@@ -51,7 +51,7 @@ int main()
 				return 0;
 			},
 			check );
-		BOOST_TEST(r==1);
+		BOOST_TEST_EQ(r, 1);
 	}
 	{
 		int r = leaf::try_(
@@ -62,7 +62,7 @@ int main()
 				return 0;
 			},
 			check );
-		BOOST_TEST(r==1);
+		BOOST_TEST_EQ(r, 1);
 	}
 	return boost::report_errors();
 }
diff --git a/test/result_state_test.cpp b/test/result_state_test.cpp
index 2c3032e..bbf73ad 100644
--- a/test/result_state_test.cpp
+++ b/test/result_state_test.cpp
@@ -94,314 +94,314 @@ int main()
 	{ // value default -> copy
 		leaf::result<val> r1;
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==1);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 1);
 		leaf::result<val> r2 = r1;
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 		BOOST_TEST(eq_value(r1,r2));
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // value move -> copy
 		leaf::result<val> r1 = val();
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==1);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 1);
 		leaf::result<val> r2 = r1;
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 		BOOST_TEST(eq_value(r1,r2));
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // value copy -> copy
 		val v;
 		leaf::result<val> r1 = v;
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 		leaf::result<val> r2 = r1;
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==3);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 3);
 		BOOST_TEST(eq_value(r1,r2));
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 
 	{ // value default -> move
 		leaf::result<val> r1;
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==1);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 1);
 		leaf::result<val> r2 = std::move(r1);
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // value move -> move
 		leaf::result<val> r1 = val();
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==1);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 1);
 		leaf::result<val> r2 = std::move(r1);
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // value copy -> move
 		val v;
 		leaf::result<val> r1 = v;
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 		leaf::result<val> r2 = std::move(r1);
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==3);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 3);
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 
 	{ // value default -> assign-copy
 		leaf::result<val> r1;
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==1);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 1);
 		leaf::result<val> r2; r2=r1;
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 		BOOST_TEST(eq_value(r1,r2));
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // value move -> assign-copy
 		leaf::result<val> r1 = val();
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==1);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 1);
 		leaf::result<val> r2; r2=r1;
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 		BOOST_TEST(eq_value(r1,r2));
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // value copy -> assign-copy
 		val v;
 		leaf::result<val> r1 = v;
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 		leaf::result<val> r2; r2=r1;
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==3);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 3);
 		BOOST_TEST(eq_value(r1,r2));
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 
 	{ // value default -> assign-move
 		leaf::result<val> r1;
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==1);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 1);
 		leaf::result<val> r2; r2=std::move(r1);
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // value move -> assign-move
 		leaf::result<val> r1 = val();
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==1);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 1);
 		leaf::result<val> r2; r2=std::move(r1);
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // value copy -> assign-move
 		val v;
 		leaf::result<val> r1 = v;
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 		leaf::result<val> r2; r2=std::move(r1);
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==3);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 3);
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 
 	{ // value default -> capture -> copy
 		leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>(); } )();
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==1);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 1);
 		leaf::result<val> r2 = r1;
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 		BOOST_TEST(eq_value(r1,r2));
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // value move -> capture -> copy
 		leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>(val()); } )();
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==1);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 1);
 		leaf::result<val> r2 = r1;
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 		BOOST_TEST(eq_value(r1,r2));
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // value copy -> capture -> copy
 		leaf::result<val> r1 = capture_result<e_err>( [ ]{ val v; return leaf::result<val>(v); } )();
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==1);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 1);
 		leaf::result<val> r2 = r1;
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 		BOOST_TEST(eq_value(r1,r2));
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 
 	{ // value default -> capture -> move
 		leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>(); } )();
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==1);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 1);
 		leaf::result<val> r2 = std::move(r1);
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // value move -> capture -> move
 		leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>(val()); } )();
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==1);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 1);
 		leaf::result<val> r2 = std::move(r1);
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // value copy -> capture -> move
 		leaf::result<val> r1 = capture_result<e_err>( [ ]{ val v; return leaf::result<val>(v); } )();
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==1);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 1);
 		leaf::result<val> r2 = std::move(r1);
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 
 	{ // value default -> capture -> assign-copy
 		leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>(); } )();
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==1);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 1);
 		leaf::result<val> r2; r2=r1;
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 		BOOST_TEST(eq_value(r1,r2));
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // value move -> capture -> assign-copy
 		leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>(val()); } )();
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==1);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 1);
 		leaf::result<val> r2; r2=r1;
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 		BOOST_TEST(eq_value(r1,r2));
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // value copy -> capture -> assign-copy
 		leaf::result<val> r1 = capture_result<e_err>( [ ]{ val v; return leaf::result<val>(v); } )();
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==1);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 1);
 		leaf::result<val> r2; r2=r1;
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 		BOOST_TEST(eq_value(r1,r2));
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 
 	{ // value default -> capture -> assign-move
 		leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>(); } )();
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==1);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 1);
 		leaf::result<val> r2; r2=std::move(r1);
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // value move -> capture -> assign-move
 		leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>(val()); } )();
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==1);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 1);
 		leaf::result<val> r2; r2=std::move(r1);
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // value copy -> capture -> assign-move
 		leaf::result<val> r1 = capture_result<e_err>( [ ]{ val v; return leaf::result<val>(v); } )();
 		BOOST_TEST(r1);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==1);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 1);
 		leaf::result<val> r2; r2=std::move(r1);
 		BOOST_TEST(r2);
-		BOOST_TEST(err::count==0);
-		BOOST_TEST(val::count==2);
+		BOOST_TEST_EQ(err::count, 0);
+		BOOST_TEST_EQ(val::count, 2);
 		}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 
 	// ^^ value ^^
 	// vv error vv
@@ -411,201 +411,201 @@ int main()
 		exp.set_reset(true);
 		leaf::result<val> r1 = leaf::new_error( e_err { } );
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
-		BOOST_TEST(val::count==0);
+		BOOST_TEST_EQ(err::count, 1);
+		BOOST_TEST_EQ(val::count, 0);
 		leaf::result<val> r2 = r1;
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // error copy -> copy
 		static_store<e_err> exp;
 		exp.set_reset(true);
 		leaf::error_id err = leaf::new_error( e_err{ } );
 		leaf::result<val> r1 = err;
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
-		BOOST_TEST(val::count==0);
+		BOOST_TEST_EQ(err::count, 1);
+		BOOST_TEST_EQ(val::count, 0);
 		leaf::result<val> r2 = r1;
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 
 	{ // error move -> move
 		static_store<e_err> exp;
 		exp.set_reset(true);
 		leaf::result<val> r1 = leaf::new_error( e_err { } );
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
-		BOOST_TEST(val::count==0);
+		BOOST_TEST_EQ(err::count, 1);
+		BOOST_TEST_EQ(val::count, 0);
 		leaf::result<val> r2 = std::move(r1);
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // error copy -> move
 		static_store<e_err> exp;
 		leaf::error_id err = leaf::new_error( e_err{ } );
 		leaf::result<val> r1 = err;
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
-		BOOST_TEST(val::count==0);
+		BOOST_TEST_EQ(err::count, 1);
+		BOOST_TEST_EQ(val::count, 0);
 		leaf::result<val> r2 = std::move(r1);
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 
 	{ // error move -> assign copy
 		static_store<e_err> exp;
 		leaf::result<val> r1 = leaf::new_error( e_err { } );
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
-		BOOST_TEST(val::count==0);
+		BOOST_TEST_EQ(err::count, 1);
+		BOOST_TEST_EQ(val::count, 0);
 		leaf::result<val> r2; r2=r1;
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // error copy -> assign copy
 		static_store<e_err> exp;
 		leaf::error_id err = leaf::new_error( e_err{ } );
 		leaf::result<val> r1 = err;
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
-		BOOST_TEST(val::count==0);
+		BOOST_TEST_EQ(err::count, 1);
+		BOOST_TEST_EQ(val::count, 0);
 		leaf::result<val> r2; r2=r1;
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 
 	{ // error move -> assign move
 		static_store<e_err> exp;
 		leaf::result<val> r1 = leaf::new_error( e_err { } );
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
-		BOOST_TEST(val::count==0);
+		BOOST_TEST_EQ(err::count, 1);
+		BOOST_TEST_EQ(val::count, 0);
 		leaf::result<val> r2; r2=std::move(r1);
 		BOOST_TEST(!r2);
 		exp.handle_error(leaf::error_info(r2.error()), [ ]{ });
-		BOOST_TEST(err::count==1);
-		BOOST_TEST(val::count==0);
+		BOOST_TEST_EQ(err::count, 1);
+		BOOST_TEST_EQ(val::count, 0);
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // error copy -> assign move
 		static_store<e_err> exp;
 		leaf::error_id err = leaf::new_error( e_err{ } );
 		leaf::result<val> r1 = err;
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
-		BOOST_TEST(val::count==0);
+		BOOST_TEST_EQ(err::count, 1);
+		BOOST_TEST_EQ(val::count, 0);
 		leaf::result<val> r2; r2=std::move(r1);
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 
 	{ // error move -> capture -> copy
 		leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>( leaf::new_error( e_err { } ) ); } )();
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
-		BOOST_TEST(val::count==0);
+		BOOST_TEST_EQ(err::count, 1);
+		BOOST_TEST_EQ(val::count, 0);
 		leaf::result<val> r2 = r1;
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // error copy -> capture -> copy
 		leaf::result<val> r1 = capture_result<e_err>( [ ] { leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<val>(err); } )();
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
-		BOOST_TEST(val::count==0);
+		BOOST_TEST_EQ(err::count, 1);
+		BOOST_TEST_EQ(val::count, 0);
 		leaf::result<val> r2 = r1;
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 
 	{ // error move -> capture -> move
 		leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>( leaf::new_error( e_err { } ) ); } )();
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
-		BOOST_TEST(val::count==0);
+		BOOST_TEST_EQ(err::count, 1);
+		BOOST_TEST_EQ(val::count, 0);
 		leaf::result<val> r2 = std::move(r1);
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // error copy -> capture -> move
 		leaf::result<val> r1 = capture_result<e_err>( [ ]{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<val>(err); } )();
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
-		BOOST_TEST(val::count==0);
+		BOOST_TEST_EQ(err::count, 1);
+		BOOST_TEST_EQ(val::count, 0);
 		leaf::result<val> r2 = std::move(r1);
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 
 	{ // error move -> capture -> assign-copy
 		leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>( leaf::new_error( e_err { } ) ); } )();
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
-		BOOST_TEST(val::count==0);
+		BOOST_TEST_EQ(err::count, 1);
+		BOOST_TEST_EQ(val::count, 0);
 		leaf::result<val> r2; r2=r1;
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // error copy -> capture -> assign-copy
 		leaf::result<val> r1 = capture_result<e_err>( [ ]{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<val>(err); } )();
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
-		BOOST_TEST(val::count==0);
+		BOOST_TEST_EQ(err::count, 1);
+		BOOST_TEST_EQ(val::count, 0);
 		leaf::result<val> r2; r2=r1;
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 
 	{ // error move -> capture -> assign-move
 		leaf::result<val> r1 = capture_result<e_err>( [ ]{ return leaf::result<val>( leaf::new_error( e_err { } ) ); } )();
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
-		BOOST_TEST(val::count==0);
+		BOOST_TEST_EQ(err::count, 1);
+		BOOST_TEST_EQ(val::count, 0);
 		leaf::result<val> r2; r2=std::move(r1);
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 	{ // error copy -> capture -> assign-move
 		leaf::result<val> r1 = capture_result<e_err>( [ ]{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<val>(err); } )();
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
-		BOOST_TEST(val::count==0);
+		BOOST_TEST_EQ(err::count, 1);
+		BOOST_TEST_EQ(val::count, 0);
 		leaf::result<val> r2; r2=std::move(r1);
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
-	BOOST_TEST(val::count==0);
+	BOOST_TEST_EQ(err::count, 0);
+	BOOST_TEST_EQ(val::count, 0);
 
 	// ^^ result<T> ^^
 
@@ -677,168 +677,168 @@ int main()
 		exp.set_reset(true);
 		leaf::result<void> r1 = leaf::new_error( e_err { } );
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
+		BOOST_TEST_EQ(err::count, 1);
 		leaf::result<void> r2 = r1;
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
+	BOOST_TEST_EQ(err::count, 0);
 	{ // void error copy -> copy
 		static_store<e_err> exp;
 		exp.set_reset(true);
 		leaf::error_id err = leaf::new_error( e_err{ } );
 		leaf::result<void> r1 = err;
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
+		BOOST_TEST_EQ(err::count, 1);
 		leaf::result<void> r2 = r1;
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
+	BOOST_TEST_EQ(err::count, 0);
 
 	{ // void error move -> move
 		static_store<e_err> exp;
 		exp.set_reset(true);
 		leaf::result<void> r1 = leaf::new_error( e_err { } );
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
+		BOOST_TEST_EQ(err::count, 1);
 		leaf::result<void> r2 = std::move(r1);
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
+	BOOST_TEST_EQ(err::count, 0);
 	{ // void error copy -> move
 		static_store<e_err> exp;
 		leaf::error_id err = leaf::new_error( e_err{ } );
 		leaf::result<void> r1 = err;
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
+		BOOST_TEST_EQ(err::count, 1);
 		leaf::result<void> r2 = std::move(r1);
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
+	BOOST_TEST_EQ(err::count, 0);
 
 	{ // void error move -> assign copy
 		static_store<e_err> exp;
 		leaf::result<void> r1 = leaf::new_error( e_err { } );
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
+		BOOST_TEST_EQ(err::count, 1);
 		leaf::result<void> r2; r2=r1;
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
+	BOOST_TEST_EQ(err::count, 0);
 	{ // void error copy -> assign copy
 		static_store<e_err> exp;
 		leaf::error_id err = leaf::new_error( e_err{ } );
 		leaf::result<void> r1 = err;
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
+		BOOST_TEST_EQ(err::count, 1);
 		leaf::result<void> r2; r2=r1;
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
+	BOOST_TEST_EQ(err::count, 0);
 
 	{ // void error move -> assign move
 		static_store<e_err> exp;
 		leaf::result<void> r1 = leaf::new_error( e_err { } );
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
+		BOOST_TEST_EQ(err::count, 1);
 		leaf::result<void> r2; r2=std::move(r1);
 		BOOST_TEST(!r2);
 		exp.handle_error(leaf::error_info(r2.error()), [ ]{ });
-		BOOST_TEST(err::count==1);
+		BOOST_TEST_EQ(err::count, 1);
 	}
-	BOOST_TEST(err::count==0);
+	BOOST_TEST_EQ(err::count, 0);
 	{ // void error copy -> assign move
 		static_store<e_err> exp;
 		leaf::error_id err = leaf::new_error( e_err{ } );
 		leaf::result<void> r1 = err;
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
+		BOOST_TEST_EQ(err::count, 1);
 		leaf::result<void> r2; r2=std::move(r1);
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
+	BOOST_TEST_EQ(err::count, 0);
 
 	{ // void error move -> capture -> copy
 		leaf::result<void> r1 = capture_result<e_err>( [ ]{ return leaf::result<void>( leaf::new_error( e_err { } ) ); } )();
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
+		BOOST_TEST_EQ(err::count, 1);
 		leaf::result<void> r2 = r1;
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
+	BOOST_TEST_EQ(err::count, 0);
 	{ // void error copy -> capture -> copy
 		leaf::result<void> r1 = capture_result<e_err>( [ ] { leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<void>(err); } )();
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
+		BOOST_TEST_EQ(err::count, 1);
 		leaf::result<void> r2 = r1;
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
+	BOOST_TEST_EQ(err::count, 0);
 
 	{ // void error move -> capture -> move
 		leaf::result<void> r1 = capture_result<e_err>( [ ]{ return leaf::result<void>( leaf::new_error( e_err { } ) ); } )();
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
+		BOOST_TEST_EQ(err::count, 1);
 		leaf::result<void> r2 = std::move(r1);
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
+	BOOST_TEST_EQ(err::count, 0);
 	{ // void error copy -> capture -> move
 		leaf::result<void> r1 = capture_result<e_err>( [ ]{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<void>(err); } )();
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
+		BOOST_TEST_EQ(err::count, 1);
 		leaf::result<void> r2 = std::move(r1);
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
+	BOOST_TEST_EQ(err::count, 0);
 
 	{ // void error move -> capture -> assign-copy
 		leaf::result<void> r1 = capture_result<e_err>( [ ]{ return leaf::result<void>( leaf::new_error( e_err { } ) ); } )();
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
+		BOOST_TEST_EQ(err::count, 1);
 		leaf::result<void> r2; r2=r1;
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
+	BOOST_TEST_EQ(err::count, 0);
 	{ // void error copy -> capture -> assign-copy
 		leaf::result<void> r1 = capture_result<e_err>( [ ]{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<void>(err); } )();
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
+		BOOST_TEST_EQ(err::count, 1);
 		leaf::result<void> r2; r2=r1;
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
+	BOOST_TEST_EQ(err::count, 0);
 
 	{ // void error move -> capture -> assign-move
 		leaf::result<void> r1 = capture_result<e_err>( [ ]{ return leaf::result<void>( leaf::new_error( e_err { } ) ); } )();
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
+		BOOST_TEST_EQ(err::count, 1);
 		leaf::result<void> r2; r2=std::move(r1);
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
+	BOOST_TEST_EQ(err::count, 0);
 	{ // void error copy -> capture -> assign-move
 		leaf::result<void> r1 = capture_result<e_err>( [ ]{ leaf::error_id err = leaf::new_error( e_err{ } ); return leaf::result<void>(err); } )();
 		BOOST_TEST(!r1);
-		BOOST_TEST(err::count==1);
+		BOOST_TEST_EQ(err::count, 1);
 		leaf::result<void> r2; r2=std::move(r1);
 		BOOST_TEST(!r2);
-		BOOST_TEST(r1.error()==r2.error());
+		BOOST_TEST_EQ(r1.error(), r2.error());
 	}
-	BOOST_TEST(err::count==0);
+	BOOST_TEST_EQ(err::count, 0);
 
 	return boost::report_errors();
 }
diff --git a/test/try_exception_and_result_test.cpp b/test/try_exception_and_result_test.cpp
index e175889..875ce63 100644
--- a/test/try_exception_and_result_test.cpp
+++ b/test/try_exception_and_result_test.cpp
@@ -26,7 +26,8 @@ int main()
 			{
 				return { };
 			} );
-		BOOST_TEST(r && r.value()==42);
+		BOOST_TEST(r);
+		BOOST_TEST_EQ(r.value(), 42);
 	}
 	{
 		leaf::result<int> r = leaf::try_(
@@ -36,10 +37,11 @@ int main()
 			},
 			[ ]( leaf::catch_<my_exception>, info<1> const & x ) -> leaf::result<int>
 			{
-				BOOST_TEST(x.value==1);
+				BOOST_TEST_EQ(x.value, 1);
 				return 42;
 			} );
-		BOOST_TEST(r && r.value()==42);
+		BOOST_TEST(r);
+		BOOST_TEST_EQ(r.value(), 42);
 	}
 	{
 		leaf::result<int> r = leaf::try_(
@@ -49,10 +51,11 @@ int main()
 			},
 			[ ]( info<1> const & x ) -> leaf::result<int>
 			{
-				BOOST_TEST(x.value==1);
+				BOOST_TEST_EQ(x.value, 1);
 				return 42;
 			} );
-		BOOST_TEST(r && r.value()==42);
+		BOOST_TEST(r);
+		BOOST_TEST_EQ(r.value(), 42);
 	}
 	return boost::report_errors();
 }
diff --git a/test/try_exception_test.cpp b/test/try_exception_test.cpp
index cfee9c8..df5d681 100644
--- a/test/try_exception_test.cpp
+++ b/test/try_exception_test.cpp
@@ -47,16 +47,16 @@ int test( F && f )
 
 int main()
 {
-	BOOST_TEST( 5==test( [ ] { throw my_error(); } ) );
+	BOOST_TEST_EQ( 5, test( [ ] { throw my_error(); } ) );
 
-	BOOST_TEST( 5==test( [ ] { throw leaf::exception(my_error()); } ) );
-	BOOST_TEST( 3==test( [ ] { throw leaf::exception(my_error(),info{42}); } ) );
+	BOOST_TEST_EQ( 5, test( [ ] { throw leaf::exception(my_error()); } ) );
+	BOOST_TEST_EQ( 3, test( [ ] { throw leaf::exception(my_error(),info{42}); } ) );
 
-	BOOST_TEST( 4==test( [ ] { throw LEAF_EXCEPTION(my_error()); } ) );
-	BOOST_TEST( 2==test( [ ] { throw LEAF_EXCEPTION(my_error(),info{42}); } ) );
+	BOOST_TEST_EQ( 4, test( [ ] { throw LEAF_EXCEPTION(my_error()); } ) );
+	BOOST_TEST_EQ( 2, test( [ ] { throw LEAF_EXCEPTION(my_error(),info{42}); } ) );
 
-	BOOST_TEST( 4==test( [ ] { LEAF_THROW(my_error()); } ) );
-	BOOST_TEST( 2==test( [ ] { LEAF_THROW(my_error(),info{42}); } ) );
+	BOOST_TEST_EQ( 4, test( [ ] { LEAF_THROW(my_error()); } ) );
+	BOOST_TEST_EQ( 2, test( [ ] { LEAF_THROW(my_error(),info{42}); } ) );
 
 	return boost::report_errors();
 }
diff --git a/test/try_test.cpp b/test/try_test.cpp
index 4b158e5..9019f8f 100644
--- a/test/try_test.cpp
+++ b/test/try_test.cpp
@@ -40,10 +40,10 @@ int main()
 			},
 			[&c]
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			} );
-		BOOST_TEST(c==42);
+		BOOST_TEST_EQ(c, 42);
 	}
 
 	// void, handle_all (failure), match_enum (single enum value)
@@ -56,22 +56,22 @@ int main()
 			},
 			[&c]( leaf::catch_<error2> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			},
 			[&c]( leaf::catch_<error1>, info<1> const & x, info<2> y )
 			{
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 	}
 
 	// void, handle_all (failure), match_enum (multiple enum values)
@@ -84,22 +84,22 @@ int main()
 			},
 			[&c]( leaf::catch_<error2> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			},
 			[&c]( leaf::catch_<error2,error1>, info<1> const & x, info<2> y )
 			{
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 	}
 
 	// void, handle_all (failure), match_value (single value)
@@ -112,22 +112,22 @@ int main()
 			},
 			[&c]( leaf::catch_<error2> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			},
 			[&c]( leaf::catch_<error1>, info<1> const & x, info<2> y )
 			{
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 	}
 
 	// void, handle_all (failure), match_value (multiple values)
@@ -140,22 +140,22 @@ int main()
 			},
 			[&c]( leaf::catch_<error2> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 1;
 			},
 			[&c]( leaf::catch_<error2,error1>, info<1> const & x, info<2> y )
 			{
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 	}
 
 	//////////////////////////////////////
@@ -173,24 +173,24 @@ int main()
 					},
 					[&c]( leaf::catch_<error2> )
 					{
-						BOOST_TEST(c==0);
+						BOOST_TEST_EQ(c, 0);
 						c = 1;
 					} );
 				BOOST_TEST(false);
 			},
 			[&c]( leaf::catch_<error1>, info<1> const & x, info<2> y )
 			{
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 	}
 
 	// void, handle_some (failure, initially not matched), match_enum (multiple enum values)
@@ -206,24 +206,24 @@ int main()
 					},
 					[&c]( leaf::catch_<error2> )
 					{
-						BOOST_TEST(c==0);
+						BOOST_TEST_EQ(c, 0);
 						c = 1;
 					} );
 				BOOST_TEST(false);
 			},
 			[&c]( leaf::catch_<error2,error1>, info<1> const & x, info<2> y )
 			{
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==2);
+		BOOST_TEST_EQ(c, 2);
 	}
 
 	// void, handle_some (failure, initially matched), match_enum (single enum value)
@@ -239,23 +239,23 @@ int main()
 					},
 					[&c]( leaf::catch_<error1> ec, info<1> const & x, info<2> y )
 					{
-						BOOST_TEST(x.value==1);
-						BOOST_TEST(y.value==2);
-						BOOST_TEST(c==0);
+						BOOST_TEST_EQ(x.value, 1);
+						BOOST_TEST_EQ(y.value, 2);
+						BOOST_TEST_EQ(c, 0);
 						c = 1;
 					} );
 			},
 			[&c]( leaf::catch_<error2> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==1);
+		BOOST_TEST_EQ(c, 1);
 	}
 
 	// void, handle_some (failure, initially matched), match_enum (multiple enum values)
@@ -271,23 +271,23 @@ int main()
 					},
 					[&c]( leaf::catch_<error2,error1>, info<1> const & x, info<2> y )
 					{
-						BOOST_TEST(x.value==1);
-						BOOST_TEST(y.value==2);
-						BOOST_TEST(c==0);
+						BOOST_TEST_EQ(x.value, 1);
+						BOOST_TEST_EQ(y.value, 2);
+						BOOST_TEST_EQ(c, 0);
 						c = 1;
 					} );
 			},
 			[&c]( leaf::catch_<error2> )
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 2;
 			},
 			[&c]
 			{
-				BOOST_TEST(c==0);
+				BOOST_TEST_EQ(c, 0);
 				c = 3;
 			} );
-		BOOST_TEST(c==1);
+		BOOST_TEST_EQ(c, 1);
 	}
 
 	//////////////////////////////////////
@@ -303,7 +303,7 @@ int main()
 			{
 				return 1;
 			} );
-		BOOST_TEST(r==42);
+		BOOST_TEST_EQ(r, 42);
 	}
 
 	// int, handle_all (failure), match_enum (single enum value)
@@ -319,15 +319,15 @@ int main()
 			},
 			[ ]( leaf::catch_<error1>, info<1> const & x, info<2> y )
 			{
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			},
 			[ ]
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 
 	// int, handle_all (failure), match_enum (multiple enum values)
@@ -343,15 +343,15 @@ int main()
 			},
 			[ ]( leaf::catch_<error2,error1>, info<1> const & x, info<2> y )
 			{
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			},
 			[ ]
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 
 	//////////////////////////////////////
@@ -369,11 +369,11 @@ int main()
 			},
 			[ ]( leaf::catch_<error1>, info<1> const & x, info<2> y )
 			{
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 
 	// int, handle_some (failure, matched), match_enum (multiple enum values)
@@ -389,11 +389,11 @@ int main()
 			},
 			[ ]( leaf::catch_<error2,error1>, info<1> const & x, info<2> y )
 			{
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 
 	// int, handle_some (failure, initially not matched), match_enum (single enum value)
@@ -415,15 +415,15 @@ int main()
 			},
 			[ ]( leaf::catch_<error1>, info<1> const & x, info<2> y )
 			{
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			},
 			[ ]
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 
 	// int, handle_some (failure, initially not matched), match_enum (multiple enum values)
@@ -445,15 +445,15 @@ int main()
 			},
 			[ ]( leaf::catch_<error2,error1>, info<1> const & x, info<2> y )
 			{
-				BOOST_TEST(x.value==1);
-				BOOST_TEST(y.value==2);
+				BOOST_TEST_EQ(x.value, 1);
+				BOOST_TEST_EQ(y.value, 2);
 				return 2;
 			},
 			[ ]
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==2);
+		BOOST_TEST_EQ(r, 2);
 	}
 
 	// int, handle_some (failure, initially matched), match_enum (single enum value)
@@ -468,11 +468,11 @@ int main()
 					},
 					[ ]( leaf::catch_<error1>, info<1> const & x, info<2> y )
 					{
-						BOOST_TEST(x.value==1);
-						BOOST_TEST(y.value==2);
+						BOOST_TEST_EQ(x.value, 1);
+						BOOST_TEST_EQ(y.value, 2);
 						return 1;
 					} );
-				BOOST_TEST(r==1);
+				BOOST_TEST_EQ(r, 1);
 				return r;
 			},
 			[ ]( leaf::catch_<error1> )
@@ -483,7 +483,7 @@ int main()
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==1);
+		BOOST_TEST_EQ(r, 1);
 	}
 
 	// int, handle_some (failure, initially matched), match_enum (multiple enum values)
@@ -498,11 +498,11 @@ int main()
 					},
 					[ ]( leaf::catch_<error2,error1>, info<1> const & x, info<2> y )
 					{
-						BOOST_TEST(x.value==1);
-						BOOST_TEST(y.value==2);
+						BOOST_TEST_EQ(x.value, 1);
+						BOOST_TEST_EQ(y.value, 2);
 						return 1;
 					} );
-				BOOST_TEST(r==1);
+				BOOST_TEST_EQ(r, 1);
 				return r;
 			},
 			[ ]( leaf::catch_<error1> )
@@ -513,7 +513,7 @@ int main()
 			{
 				return 3;
 			} );
-		BOOST_TEST(r==1);
+		BOOST_TEST_EQ(r, 1);
 	}
 
 	//////////////////////////////////////