diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 08337da..91f25d5 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -1128,7 +1128,8 @@
 
 // Verifies that the relative error of |actual| with respect to |expected| is
 // no more than |margin|.
-
+// Please use EXPECT_APPROX_EQ, a wrapper around this function, for better error
+// report.
 template <typename T>
 void ExpectApproxEq(T expected, T actual, float relative_margin) {
   // If |relative_margin| > 1 and T is an unsigned type, the comparison will
@@ -1138,10 +1139,16 @@
 
   T absolute_margin = expected * relative_margin;
 
-  EXPECT_GE(expected + absolute_margin, actual);
-  EXPECT_LE(expected - absolute_margin, actual);
+  EXPECT_GE(expected + absolute_margin, actual) << "actual value too big";
+  EXPECT_LE(expected - absolute_margin, actual) << "actual value too small";
 }
 
+#define EXPECT_APPROX_EQ(expected, actual, relative_margin)                    \
+  do {                                                                         \
+    SCOPED_TRACE(testing::Message() << "relative_margin:" << relative_margin); \
+    quic::test::ExpectApproxEq(expected, actual, relative_margin);             \
+  } while (0)
+
 template <typename T>
 QuicHeaderList AsHeaderList(const T& container) {
   QuicHeaderList l;
diff --git a/quic/test_tools/quic_test_utils_test.cc b/quic/test_tools/quic_test_utils_test.cc
index 8c30335..31e4804 100644
--- a/quic/test_tools/quic_test_utils_test.cc
+++ b/quic/test_tools/quic_test_utils_test.cc
@@ -22,29 +22,29 @@
 }
 
 TEST_F(QuicTestUtilsTest, BasicApproxEq) {
-  ExpectApproxEq(10, 10, 1e-6f);
-  ExpectApproxEq(1000, 1001, 0.01f);
-  EXPECT_NONFATAL_FAILURE(ExpectApproxEq(1000, 1100, 0.01f), "");
+  EXPECT_APPROX_EQ(10, 10, 1e-6f);
+  EXPECT_APPROX_EQ(1000, 1001, 0.01f);
+  EXPECT_NONFATAL_FAILURE(EXPECT_APPROX_EQ(1000, 1100, 0.01f), "");
 
-  ExpectApproxEq(64, 31, 0.55f);
-  EXPECT_NONFATAL_FAILURE(ExpectApproxEq(31, 64, 0.55f), "");
+  EXPECT_APPROX_EQ(64, 31, 0.55f);
+  EXPECT_NONFATAL_FAILURE(EXPECT_APPROX_EQ(31, 64, 0.55f), "");
 }
 
 TEST_F(QuicTestUtilsTest, QuicTimeDelta) {
-  ExpectApproxEq(QuicTime::Delta::FromMicroseconds(1000),
-                 QuicTime::Delta::FromMicroseconds(1003), 0.01f);
+  EXPECT_APPROX_EQ(QuicTime::Delta::FromMicroseconds(1000),
+                   QuicTime::Delta::FromMicroseconds(1003), 0.01f);
   EXPECT_NONFATAL_FAILURE(
-      ExpectApproxEq(QuicTime::Delta::FromMicroseconds(1000),
-                     QuicTime::Delta::FromMicroseconds(1200), 0.01f),
+      EXPECT_APPROX_EQ(QuicTime::Delta::FromMicroseconds(1000),
+                       QuicTime::Delta::FromMicroseconds(1200), 0.01f),
       "");
 }
 
 TEST_F(QuicTestUtilsTest, QuicBandwidth) {
-  ExpectApproxEq(QuicBandwidth::FromBytesPerSecond(1000),
-                 QuicBandwidth::FromBitsPerSecond(8005), 0.01f);
+  EXPECT_APPROX_EQ(QuicBandwidth::FromBytesPerSecond(1000),
+                   QuicBandwidth::FromBitsPerSecond(8005), 0.01f);
   EXPECT_NONFATAL_FAILURE(
-      ExpectApproxEq(QuicBandwidth::FromBytesPerSecond(1000),
-                     QuicBandwidth::FromBitsPerSecond(9005), 0.01f),
+      EXPECT_APPROX_EQ(QuicBandwidth::FromBytesPerSecond(1000),
+                       QuicBandwidth::FromBitsPerSecond(9005), 0.01f),
       "");
 }
 
diff --git a/quic/test_tools/simulator/simulator_test.cc b/quic/test_tools/simulator/simulator_test.cc
index 33ad564..1e7a8ce 100644
--- a/quic/test_tools/simulator/simulator_test.cc
+++ b/quic/test_tools/simulator/simulator_test.cc
@@ -224,7 +224,7 @@
   const QuicTime end_time = simulator.GetClock()->Now();
   const QuicBandwidth observed_bandwidth = QuicBandwidth::FromBytesAndTimeDelta(
       saturator_a.bytes_transmitted(), end_time - start_time);
-  test::ExpectApproxEq(link.bandwidth(), observed_bandwidth, 0.01f);
+  EXPECT_APPROX_EQ(link.bandwidth(), observed_bandwidth, 0.01f);
 }
 
 // Accepts packets and stores them internally.
@@ -683,15 +683,15 @@
 
   // Ensure we've transmitted the amount of data we expected.
   for (auto* saturator : {&saturator1, &saturator2}) {
-    test::ExpectApproxEq(bandwidth * simulation_time,
-                         saturator->bytes_transmitted(), 0.01f);
+    EXPECT_APPROX_EQ(bandwidth * simulation_time,
+                     saturator->bytes_transmitted(), 0.01f);
   }
 
   // Check that only one direction is throttled.
-  test::ExpectApproxEq(saturator1.bytes_transmitted() / 4,
-                       saturator2.counter()->bytes(), 0.1f);
-  test::ExpectApproxEq(saturator2.bytes_transmitted(),
-                       saturator1.counter()->bytes(), 0.1f);
+  EXPECT_APPROX_EQ(saturator1.bytes_transmitted() / 4,
+                   saturator2.counter()->bytes(), 0.1f);
+  EXPECT_APPROX_EQ(saturator2.bytes_transmitted(),
+                   saturator1.counter()->bytes(), 0.1f);
 }
 
 // Ensure that a larger burst is allowed when the policed saturator exits
@@ -740,14 +740,14 @@
   simulator.RunFor(2 * base_propagation_delay);
 
   // Expect the burst to pass without losses.
-  test::ExpectApproxEq(saturator1.bytes_transmitted(),
-                       saturator2.counter()->bytes(), 0.1f);
+  EXPECT_APPROX_EQ(saturator1.bytes_transmitted(),
+                   saturator2.counter()->bytes(), 0.1f);
 
   // Expect subsequent traffic to be policed.
   saturator1.Resume();
   simulator.RunFor(QuicTime::Delta::FromSeconds(10));
-  test::ExpectApproxEq(saturator1.bytes_transmitted() / 4,
-                       saturator2.counter()->bytes(), 0.1f);
+  EXPECT_APPROX_EQ(saturator1.bytes_transmitted() / 4,
+                   saturator2.counter()->bytes(), 0.1f);
 }
 
 // Test that the packet aggregation support in queues work.