diff --git a/test/unittests/value-serializer-unittest.cc b/test/unittests/value-serializer-unittest.cc
index 06d38bbe4c..3a997b62ec 100644
--- a/test/unittests/value-serializer-unittest.cc
+++ b/test/unittests/value-serializer-unittest.cc
@@ -87,36 +87,27 @@ class ValueSerializerTest : public TestWithIsolate {
   }
   virtual void BeforeDecode(ValueDeserializer*) {}
 
-  template <typename InputFunctor, typename OutputFunctor>
-  void RoundTripTest(const InputFunctor& input_functor,
-                     const OutputFunctor& output_functor) {
-    EncodeTest(input_functor,
-               [this, &output_functor](const std::vector<uint8_t>& data) {
-                 DecodeTest(data, output_functor);
-               });
+  Local<Value> RoundTripTest(Local<Value> input_value) {
+    std::vector<uint8_t> encoded = EncodeTest(input_value);
+    return DecodeTest(encoded);
   }
 
   // Variant for the common case where a script is used to build the original
   // value.
-  template <typename OutputFunctor>
-  void RoundTripTest(const char* source, const OutputFunctor& output_functor) {
-    RoundTripTest([this, source]() { return EvaluateScriptForInput(source); },
-                  output_functor);
+  Local<Value> RoundTripTest(const char* source) {
+    return RoundTripTest(EvaluateScriptForInput(source));
   }
 
   // Variant which uses JSON.parse/stringify to check the result.
   void RoundTripJSON(const char* source) {
-    RoundTripTest(
-        [this, source]() {
-          return JSON::Parse(serialization_context_, StringFromUtf8(source))
-              .ToLocalChecked();
-        },
-        [this, source](Local<Value> value) {
-          ASSERT_TRUE(value->IsObject());
-          EXPECT_EQ(source, Utf8Value(JSON::Stringify(deserialization_context_,
-                                                      value.As<Object>())
-                                          .ToLocalChecked()));
-        });
+    Local<Value> input_value =
+        JSON::Parse(serialization_context_, StringFromUtf8(source))
+            .ToLocalChecked();
+    Local<Value> result = RoundTripTest(input_value);
+    ASSERT_TRUE(result->IsObject());
+    EXPECT_EQ(source, Utf8Value(JSON::Stringify(deserialization_context_,
+                                                result.As<Object>())
+                                    .ToLocalChecked()));
   }
 
   Maybe<std::vector<uint8_t>> DoEncode(Local<Value> value) {
@@ -134,41 +125,33 @@ class ValueSerializerTest : public TestWithIsolate {
     return Just(std::move(result));
   }
 
-  template <typename InputFunctor, typename EncodedDataFunctor>
-  void EncodeTest(const InputFunctor& input_functor,
-                  const EncodedDataFunctor& encoded_data_functor) {
+  std::vector<uint8_t> EncodeTest(Local<Value> input_value) {
     Context::Scope scope(serialization_context());
     TryCatch try_catch(isolate());
-    Local<Value> input_value = input_functor();
     std::vector<uint8_t> buffer;
-    ASSERT_TRUE(DoEncode(input_value).To(&buffer));
-    ASSERT_FALSE(try_catch.HasCaught());
-    encoded_data_functor(buffer);
+    // Ideally we would use GTest's ASSERT_* macros here and below. However,
+    // those only work in functions returning {void}, and they only terminate
+    // the current function, but not the entire current test (so we would need
+    // additional manual checks whether it is okay to proceed). Given that our
+    // test driver starts a new process for each test anyway, it is acceptable
+    // to just use a CHECK (which would kill the process on failure) instead.
+    CHECK(DoEncode(input_value).To(&buffer));
+    CHECK(!try_catch.HasCaught());
+    return buffer;
   }
 
-  template <typename InputFunctor, typename MessageFunctor>
-  void InvalidEncodeTest(const InputFunctor& input_functor,
-                         const MessageFunctor& functor) {
+  v8::Local<v8::Message> InvalidEncodeTest(Local<Value> input_value) {
     Context::Scope scope(serialization_context());
     TryCatch try_catch(isolate());
-    Local<Value> input_value = input_functor();
-    ASSERT_TRUE(DoEncode(input_value).IsNothing());
-    functor(try_catch.Message());
+    CHECK(DoEncode(input_value).IsNothing());
+    return try_catch.Message();
   }
 
-  template <typename MessageFunctor>
-  void InvalidEncodeTest(const char* source, const MessageFunctor& functor) {
-    InvalidEncodeTest(
-        [this, source]() { return EvaluateScriptForInput(source); }, functor);
+  v8::Local<v8::Message> InvalidEncodeTest(const char* source) {
+    return InvalidEncodeTest(EvaluateScriptForInput(source));
   }
 
-  void InvalidEncodeTest(const char* source) {
-    InvalidEncodeTest(source, [](Local<Message>) {});
-  }
-
-  template <typename OutputFunctor>
-  void DecodeTest(const std::vector<uint8_t>& data,
-                  const OutputFunctor& output_functor) {
+  Local<Value> DecodeTest(const std::vector<uint8_t>& data) {
     Local<Context> context = deserialization_context();
     Context::Scope scope(context);
     TryCatch try_catch(isolate());
@@ -178,22 +161,19 @@ class ValueSerializerTest : public TestWithIsolate {
     deserializer.SetSupportsLegacyWireFormat(true);
     deserializer.SetExpectInlineWasm(ExpectInlineWasm());
     BeforeDecode(&deserializer);
-    ASSERT_TRUE(deserializer.ReadHeader(context).FromMaybe(false));
+    CHECK(deserializer.ReadHeader(context).FromMaybe(false));
     Local<Value> result;
-    ASSERT_TRUE(deserializer.ReadValue(context).ToLocal(&result));
-    ASSERT_FALSE(result.IsEmpty());
-    ASSERT_FALSE(try_catch.HasCaught());
-    ASSERT_TRUE(
-        context->Global()
-            ->CreateDataProperty(context, StringFromUtf8("result"), result)
-            .FromMaybe(false));
-    output_functor(result);
-    ASSERT_FALSE(try_catch.HasCaught());
+    CHECK(deserializer.ReadValue(context).ToLocal(&result));
+    CHECK(!result.IsEmpty());
+    CHECK(!try_catch.HasCaught());
+    CHECK(context->Global()
+              ->CreateDataProperty(context, StringFromUtf8("result"), result)
+              .FromMaybe(false));
+    CHECK(!try_catch.HasCaught());
+    return result;
   }
 
-  template <typename OutputFunctor>
-  void DecodeTestForVersion0(const std::vector<uint8_t>& data,
-                             const OutputFunctor& output_functor) {
+  Local<Value> DecodeTestForVersion0(const std::vector<uint8_t>& data) {
     Local<Context> context = deserialization_context();
     Context::Scope scope(context);
     TryCatch try_catch(isolate());
@@ -203,18 +183,17 @@ class ValueSerializerTest : public TestWithIsolate {
     deserializer.SetSupportsLegacyWireFormat(true);
     deserializer.SetExpectInlineWasm(ExpectInlineWasm());
     BeforeDecode(&deserializer);
-    ASSERT_TRUE(deserializer.ReadHeader(context).FromMaybe(false));
-    ASSERT_EQ(0u, deserializer.GetWireFormatVersion());
+    CHECK(deserializer.ReadHeader(context).FromMaybe(false));
+    CHECK_EQ(0u, deserializer.GetWireFormatVersion());
     Local<Value> result;
-    ASSERT_TRUE(deserializer.ReadValue(context).ToLocal(&result));
-    ASSERT_FALSE(result.IsEmpty());
-    ASSERT_FALSE(try_catch.HasCaught());
-    ASSERT_TRUE(
-        context->Global()
-            ->CreateDataProperty(context, StringFromUtf8("result"), result)
-            .FromMaybe(false));
-    output_functor(result);
-    ASSERT_FALSE(try_catch.HasCaught());
+    CHECK(deserializer.ReadValue(context).ToLocal(&result));
+    CHECK(!result.IsEmpty());
+    CHECK(!try_catch.HasCaught());
+    CHECK(context->Global()
+              ->CreateDataProperty(context, StringFromUtf8("result"), result)
+              .FromMaybe(false));
+    CHECK(!try_catch.HasCaught());
+    return result;
   }
 
   void InvalidDecodeTest(const std::vector<uint8_t>& data) {
@@ -232,24 +211,26 @@ class ValueSerializerTest : public TestWithIsolate {
       EXPECT_TRUE(try_catch.HasCaught());
       return;
     }
-    ASSERT_TRUE(header_result.ToChecked());
-    ASSERT_TRUE(deserializer.ReadValue(context).IsEmpty());
+    CHECK(header_result.ToChecked());
+    CHECK(deserializer.ReadValue(context).IsEmpty());
     EXPECT_TRUE(try_catch.HasCaught());
   }
 
   Local<Value> EvaluateScriptForInput(const char* utf8_source) {
+    Context::Scope scope(serialization_context_);
     Local<String> source = StringFromUtf8(utf8_source);
     Local<Script> script =
         Script::Compile(serialization_context_, source).ToLocalChecked();
     return script->Run(serialization_context_).ToLocalChecked();
   }
 
-  bool EvaluateScriptForResultBool(const char* utf8_source) {
+  void ExpectScriptTrue(const char* utf8_source) {
+    Context::Scope scope(deserialization_context_);
     Local<String> source = StringFromUtf8(utf8_source);
     Local<Script> script =
         Script::Compile(deserialization_context_, source).ToLocalChecked();
     Local<Value> value = script->Run(deserialization_context_).ToLocalChecked();
-    return value->BooleanValue(deserialization_context_).FromJust();
+    EXPECT_TRUE(value->BooleanValue(deserialization_context_).FromJust());
   }
 
   Local<String> StringFromUtf8(const char* source) {
@@ -297,123 +278,111 @@ TEST_F(ValueSerializerTest, DecodeInvalid) {
 }
 
 TEST_F(ValueSerializerTest, RoundTripOddball) {
-  RoundTripTest([this]() { return Undefined(isolate()); },
-                [](Local<Value> value) { EXPECT_TRUE(value->IsUndefined()); });
-  RoundTripTest([this]() { return True(isolate()); },
-                [](Local<Value> value) { EXPECT_TRUE(value->IsTrue()); });
-  RoundTripTest([this]() { return False(isolate()); },
-                [](Local<Value> value) { EXPECT_TRUE(value->IsFalse()); });
-  RoundTripTest([this]() { return Null(isolate()); },
-                [](Local<Value> value) { EXPECT_TRUE(value->IsNull()); });
+  Local<Value> value = RoundTripTest(Undefined(isolate()));
+  EXPECT_TRUE(value->IsUndefined());
+  value = RoundTripTest(True(isolate()));
+  EXPECT_TRUE(value->IsTrue());
+  value = RoundTripTest(False(isolate()));
+  EXPECT_TRUE(value->IsFalse());
+  value = RoundTripTest(Null(isolate()));
+  EXPECT_TRUE(value->IsNull());
 }
 
 TEST_F(ValueSerializerTest, DecodeOddball) {
   // What this code is expected to generate.
-  DecodeTest({0xFF, 0x09, 0x5F},
-             [](Local<Value> value) { EXPECT_TRUE(value->IsUndefined()); });
-  DecodeTest({0xFF, 0x09, 0x54},
-             [](Local<Value> value) { EXPECT_TRUE(value->IsTrue()); });
-  DecodeTest({0xFF, 0x09, 0x46},
-             [](Local<Value> value) { EXPECT_TRUE(value->IsFalse()); });
-  DecodeTest({0xFF, 0x09, 0x30},
-             [](Local<Value> value) { EXPECT_TRUE(value->IsNull()); });
+  Local<Value> value = DecodeTest({0xFF, 0x09, 0x5F});
+  EXPECT_TRUE(value->IsUndefined());
+  value = DecodeTest({0xFF, 0x09, 0x54});
+  EXPECT_TRUE(value->IsTrue());
+  value = DecodeTest({0xFF, 0x09, 0x46});
+  EXPECT_TRUE(value->IsFalse());
+  value = DecodeTest({0xFF, 0x09, 0x30});
+  EXPECT_TRUE(value->IsNull());
 
   // What v9 of the Blink code generates.
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x5F, 0x00},
-             [](Local<Value> value) { EXPECT_TRUE(value->IsUndefined()); });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x54, 0x00},
-             [](Local<Value> value) { EXPECT_TRUE(value->IsTrue()); });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x46, 0x00},
-             [](Local<Value> value) { EXPECT_TRUE(value->IsFalse()); });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x30, 0x00},
-             [](Local<Value> value) { EXPECT_TRUE(value->IsNull()); });
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x5F, 0x00});
+  EXPECT_TRUE(value->IsUndefined());
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x54, 0x00});
+  EXPECT_TRUE(value->IsTrue());
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x46, 0x00});
+  EXPECT_TRUE(value->IsFalse());
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x30, 0x00});
+  EXPECT_TRUE(value->IsNull());
 
   // v0 (with no explicit version).
-  DecodeTest({0x5F, 0x00},
-             [](Local<Value> value) { EXPECT_TRUE(value->IsUndefined()); });
-  DecodeTest({0x54, 0x00},
-             [](Local<Value> value) { EXPECT_TRUE(value->IsTrue()); });
-  DecodeTest({0x46, 0x00},
-             [](Local<Value> value) { EXPECT_TRUE(value->IsFalse()); });
-  DecodeTest({0x30, 0x00},
-             [](Local<Value> value) { EXPECT_TRUE(value->IsNull()); });
+  value = DecodeTest({0x5F, 0x00});
+  EXPECT_TRUE(value->IsUndefined());
+  value = DecodeTest({0x54, 0x00});
+  EXPECT_TRUE(value->IsTrue());
+  value = DecodeTest({0x46, 0x00});
+  EXPECT_TRUE(value->IsFalse());
+  value = DecodeTest({0x30, 0x00});
+  EXPECT_TRUE(value->IsNull());
 }
 
 TEST_F(ValueSerializerTest, RoundTripNumber) {
-  RoundTripTest([this]() { return Integer::New(isolate(), 42); },
-                [](Local<Value> value) {
-                  ASSERT_TRUE(value->IsInt32());
-                  EXPECT_EQ(42, Int32::Cast(*value)->Value());
-                });
-  RoundTripTest([this]() { return Integer::New(isolate(), -31337); },
-                [](Local<Value> value) {
-                  ASSERT_TRUE(value->IsInt32());
-                  EXPECT_EQ(-31337, Int32::Cast(*value)->Value());
-                });
-  RoundTripTest(
-      [this]() {
-        return Integer::New(isolate(), std::numeric_limits<int32_t>::min());
-      },
-      [](Local<Value> value) {
-        ASSERT_TRUE(value->IsInt32());
-        EXPECT_EQ(std::numeric_limits<int32_t>::min(),
-                  Int32::Cast(*value)->Value());
-      });
-  RoundTripTest([this]() { return Number::New(isolate(), -0.25); },
-                [](Local<Value> value) {
-                  ASSERT_TRUE(value->IsNumber());
-                  EXPECT_EQ(-0.25, Number::Cast(*value)->Value());
-                });
-  RoundTripTest(
-      [this]() {
-        return Number::New(isolate(), std::numeric_limits<double>::quiet_NaN());
-      },
-      [](Local<Value> value) {
-        ASSERT_TRUE(value->IsNumber());
-        EXPECT_TRUE(std::isnan(Number::Cast(*value)->Value()));
-      });
+  Local<Value> value = RoundTripTest(Integer::New(isolate(), 42));
+  ASSERT_TRUE(value->IsInt32());
+  EXPECT_EQ(42, Int32::Cast(*value)->Value());
+
+  value = RoundTripTest(Integer::New(isolate(), -31337));
+  ASSERT_TRUE(value->IsInt32());
+  EXPECT_EQ(-31337, Int32::Cast(*value)->Value());
+
+  value = RoundTripTest(
+      Integer::New(isolate(), std::numeric_limits<int32_t>::min()));
+  ASSERT_TRUE(value->IsInt32());
+  EXPECT_EQ(std::numeric_limits<int32_t>::min(), Int32::Cast(*value)->Value());
+
+  value = RoundTripTest(Number::New(isolate(), -0.25));
+  ASSERT_TRUE(value->IsNumber());
+  EXPECT_EQ(-0.25, Number::Cast(*value)->Value());
+
+  value = RoundTripTest(
+      Number::New(isolate(), std::numeric_limits<double>::quiet_NaN()));
+  ASSERT_TRUE(value->IsNumber());
+  EXPECT_TRUE(std::isnan(Number::Cast(*value)->Value()));
 }
 
 TEST_F(ValueSerializerTest, DecodeNumber) {
   // 42 zig-zag encoded (signed)
-  DecodeTest({0xFF, 0x09, 0x49, 0x54}, [](Local<Value> value) {
-    ASSERT_TRUE(value->IsInt32());
-    EXPECT_EQ(42, Int32::Cast(*value)->Value());
-  });
+  Local<Value> value = DecodeTest({0xFF, 0x09, 0x49, 0x54});
+  ASSERT_TRUE(value->IsInt32());
+  EXPECT_EQ(42, Int32::Cast(*value)->Value());
+
   // 42 varint encoded (unsigned)
-  DecodeTest({0xFF, 0x09, 0x55, 0x2A}, [](Local<Value> value) {
-    ASSERT_TRUE(value->IsInt32());
-    EXPECT_EQ(42, Int32::Cast(*value)->Value());
-  });
+  value = DecodeTest({0xFF, 0x09, 0x55, 0x2A});
+  ASSERT_TRUE(value->IsInt32());
+  EXPECT_EQ(42, Int32::Cast(*value)->Value());
+
   // 160 zig-zag encoded (signed)
-  DecodeTest({0xFF, 0x09, 0x49, 0xC0, 0x02}, [](Local<Value> value) {
-    ASSERT_TRUE(value->IsInt32());
-    ASSERT_EQ(160, Int32::Cast(*value)->Value());
-  });
+  value = DecodeTest({0xFF, 0x09, 0x49, 0xC0, 0x02});
+  ASSERT_TRUE(value->IsInt32());
+  ASSERT_EQ(160, Int32::Cast(*value)->Value());
+
   // 160 varint encoded (unsigned)
-  DecodeTest({0xFF, 0x09, 0x55, 0xA0, 0x01}, [](Local<Value> value) {
-    ASSERT_TRUE(value->IsInt32());
-    ASSERT_EQ(160, Int32::Cast(*value)->Value());
-  });
+  value = DecodeTest({0xFF, 0x09, 0x55, 0xA0, 0x01});
+  ASSERT_TRUE(value->IsInt32());
+  ASSERT_EQ(160, Int32::Cast(*value)->Value());
+
 #if defined(V8_TARGET_LITTLE_ENDIAN)
   // IEEE 754 doubles, little-endian byte order
-  DecodeTest({0xFF, 0x09, 0x4E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD0, 0xBF},
-             [](Local<Value> value) {
-               ASSERT_TRUE(value->IsNumber());
-               EXPECT_EQ(-0.25, Number::Cast(*value)->Value());
-             });
+  value = DecodeTest(
+      {0xFF, 0x09, 0x4E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD0, 0xBF});
+  ASSERT_TRUE(value->IsNumber());
+  EXPECT_EQ(-0.25, Number::Cast(*value)->Value());
+
   // quiet NaN
-  DecodeTest({0xFF, 0x09, 0x4E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x7F},
-             [](Local<Value> value) {
-               ASSERT_TRUE(value->IsNumber());
-               EXPECT_TRUE(std::isnan(Number::Cast(*value)->Value()));
-             });
+  value = DecodeTest(
+      {0xFF, 0x09, 0x4E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x7F});
+  ASSERT_TRUE(value->IsNumber());
+  EXPECT_TRUE(std::isnan(Number::Cast(*value)->Value()));
+
   // signaling NaN
-  DecodeTest({0xFF, 0x09, 0x4E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF4, 0x7F},
-             [](Local<Value> value) {
-               ASSERT_TRUE(value->IsNumber());
-               EXPECT_TRUE(std::isnan(Number::Cast(*value)->Value()));
-             });
+  value = DecodeTest(
+      {0xFF, 0x09, 0x4E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF4, 0x7F});
+  ASSERT_TRUE(value->IsNumber());
+  EXPECT_TRUE(std::isnan(Number::Cast(*value)->Value()));
 #endif
   // TODO(jbroman): Equivalent test for big-endian machines.
 }
@@ -424,103 +393,88 @@ static const char kQuebecString[] = "\x51\x75\xC3\xA9\x62\x65\x63";
 static const char kEmojiString[] = "\xF0\x9F\x91\x8A";
 
 TEST_F(ValueSerializerTest, RoundTripString) {
-  RoundTripTest([this]() { return String::Empty(isolate()); },
-                [](Local<Value> value) {
-                  ASSERT_TRUE(value->IsString());
-                  EXPECT_EQ(0, String::Cast(*value)->Length());
-                });
+  Local<Value> value = RoundTripTest(String::Empty(isolate()));
+  ASSERT_TRUE(value->IsString());
+  EXPECT_EQ(0, String::Cast(*value)->Length());
+
   // Inside ASCII.
-  RoundTripTest([this]() { return StringFromUtf8(kHelloString); },
-                [this](Local<Value> value) {
-                  ASSERT_TRUE(value->IsString());
-                  EXPECT_EQ(5, String::Cast(*value)->Length());
-                  EXPECT_EQ(kHelloString, Utf8Value(value));
-                });
+  value = RoundTripTest(StringFromUtf8(kHelloString));
+  ASSERT_TRUE(value->IsString());
+  EXPECT_EQ(5, String::Cast(*value)->Length());
+  EXPECT_EQ(kHelloString, Utf8Value(value));
+
   // Inside Latin-1 (i.e. one-byte string), but not ASCII.
-  RoundTripTest([this]() { return StringFromUtf8(kQuebecString); },
-                [this](Local<Value> value) {
-                  ASSERT_TRUE(value->IsString());
-                  EXPECT_EQ(6, String::Cast(*value)->Length());
-                  EXPECT_EQ(kQuebecString, Utf8Value(value));
-                });
+  value = RoundTripTest(StringFromUtf8(kQuebecString));
+  ASSERT_TRUE(value->IsString());
+  EXPECT_EQ(6, String::Cast(*value)->Length());
+  EXPECT_EQ(kQuebecString, Utf8Value(value));
+
   // An emoji (decodes to two 16-bit chars).
-  RoundTripTest([this]() { return StringFromUtf8(kEmojiString); },
-                [this](Local<Value> value) {
-                  ASSERT_TRUE(value->IsString());
-                  EXPECT_EQ(2, String::Cast(*value)->Length());
-                  EXPECT_EQ(kEmojiString, Utf8Value(value));
-                });
+  value = RoundTripTest(StringFromUtf8(kEmojiString));
+  ASSERT_TRUE(value->IsString());
+  EXPECT_EQ(2, String::Cast(*value)->Length());
+  EXPECT_EQ(kEmojiString, Utf8Value(value));
 }
 
 TEST_F(ValueSerializerTest, DecodeString) {
   // Decoding the strings above from UTF-8.
-  DecodeTest({0xFF, 0x09, 0x53, 0x00}, [](Local<Value> value) {
-    ASSERT_TRUE(value->IsString());
-    EXPECT_EQ(0, String::Cast(*value)->Length());
-  });
-  DecodeTest({0xFF, 0x09, 0x53, 0x05, 'H', 'e', 'l', 'l', 'o'},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsString());
-               EXPECT_EQ(5, String::Cast(*value)->Length());
-               EXPECT_EQ(kHelloString, Utf8Value(value));
-             });
-  DecodeTest({0xFF, 0x09, 0x53, 0x07, 'Q', 'u', 0xC3, 0xA9, 'b', 'e', 'c'},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsString());
-               EXPECT_EQ(6, String::Cast(*value)->Length());
-               EXPECT_EQ(kQuebecString, Utf8Value(value));
-             });
-  DecodeTest({0xFF, 0x09, 0x53, 0x04, 0xF0, 0x9F, 0x91, 0x8A},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsString());
-               EXPECT_EQ(2, String::Cast(*value)->Length());
-               EXPECT_EQ(kEmojiString, Utf8Value(value));
-             });
+  Local<Value> value = DecodeTest({0xFF, 0x09, 0x53, 0x00});
+  ASSERT_TRUE(value->IsString());
+  EXPECT_EQ(0, String::Cast(*value)->Length());
+
+  value = DecodeTest({0xFF, 0x09, 0x53, 0x05, 'H', 'e', 'l', 'l', 'o'});
+  ASSERT_TRUE(value->IsString());
+  EXPECT_EQ(5, String::Cast(*value)->Length());
+  EXPECT_EQ(kHelloString, Utf8Value(value));
+
+  value =
+      DecodeTest({0xFF, 0x09, 0x53, 0x07, 'Q', 'u', 0xC3, 0xA9, 'b', 'e', 'c'});
+  ASSERT_TRUE(value->IsString());
+  EXPECT_EQ(6, String::Cast(*value)->Length());
+  EXPECT_EQ(kQuebecString, Utf8Value(value));
+
+  value = DecodeTest({0xFF, 0x09, 0x53, 0x04, 0xF0, 0x9F, 0x91, 0x8A});
+  ASSERT_TRUE(value->IsString());
+  EXPECT_EQ(2, String::Cast(*value)->Length());
+  EXPECT_EQ(kEmojiString, Utf8Value(value));
 
   // And from Latin-1 (for the ones that fit).
-  DecodeTest({0xFF, 0x0A, 0x22, 0x00}, [](Local<Value> value) {
-    ASSERT_TRUE(value->IsString());
-    EXPECT_EQ(0, String::Cast(*value)->Length());
-  });
-  DecodeTest({0xFF, 0x0A, 0x22, 0x05, 'H', 'e', 'l', 'l', 'o'},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsString());
-               EXPECT_EQ(5, String::Cast(*value)->Length());
-               EXPECT_EQ(kHelloString, Utf8Value(value));
-             });
-  DecodeTest({0xFF, 0x0A, 0x22, 0x06, 'Q', 'u', 0xE9, 'b', 'e', 'c'},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsString());
-               EXPECT_EQ(6, String::Cast(*value)->Length());
-               EXPECT_EQ(kQuebecString, Utf8Value(value));
-             });
+  value = DecodeTest({0xFF, 0x0A, 0x22, 0x00});
+  ASSERT_TRUE(value->IsString());
+  EXPECT_EQ(0, String::Cast(*value)->Length());
+
+  value = DecodeTest({0xFF, 0x0A, 0x22, 0x05, 'H', 'e', 'l', 'l', 'o'});
+  ASSERT_TRUE(value->IsString());
+  EXPECT_EQ(5, String::Cast(*value)->Length());
+  EXPECT_EQ(kHelloString, Utf8Value(value));
+
+  value = DecodeTest({0xFF, 0x0A, 0x22, 0x06, 'Q', 'u', 0xE9, 'b', 'e', 'c'});
+  ASSERT_TRUE(value->IsString());
+  EXPECT_EQ(6, String::Cast(*value)->Length());
+  EXPECT_EQ(kQuebecString, Utf8Value(value));
 
 // And from two-byte strings (endianness dependent).
 #if defined(V8_TARGET_LITTLE_ENDIAN)
-  DecodeTest({0xFF, 0x09, 0x63, 0x00}, [](Local<Value> value) {
-    ASSERT_TRUE(value->IsString());
-    EXPECT_EQ(0, String::Cast(*value)->Length());
-  });
-  DecodeTest({0xFF, 0x09, 0x63, 0x0A, 'H', '\0', 'e', '\0', 'l', '\0', 'l',
-              '\0', 'o', '\0'},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsString());
-               EXPECT_EQ(5, String::Cast(*value)->Length());
-               EXPECT_EQ(kHelloString, Utf8Value(value));
-             });
-  DecodeTest({0xFF, 0x09, 0x63, 0x0C, 'Q', '\0', 'u', '\0', 0xE9, '\0', 'b',
-              '\0', 'e', '\0', 'c', '\0'},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsString());
-               EXPECT_EQ(6, String::Cast(*value)->Length());
-               EXPECT_EQ(kQuebecString, Utf8Value(value));
-             });
-  DecodeTest({0xFF, 0x09, 0x63, 0x04, 0x3D, 0xD8, 0x4A, 0xDC},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsString());
-               EXPECT_EQ(2, String::Cast(*value)->Length());
-               EXPECT_EQ(kEmojiString, Utf8Value(value));
-             });
+  value = DecodeTest({0xFF, 0x09, 0x63, 0x00});
+  ASSERT_TRUE(value->IsString());
+  EXPECT_EQ(0, String::Cast(*value)->Length());
+
+  value = DecodeTest({0xFF, 0x09, 0x63, 0x0A, 'H', '\0', 'e', '\0', 'l', '\0',
+                      'l', '\0', 'o', '\0'});
+  ASSERT_TRUE(value->IsString());
+  EXPECT_EQ(5, String::Cast(*value)->Length());
+  EXPECT_EQ(kHelloString, Utf8Value(value));
+
+  value = DecodeTest({0xFF, 0x09, 0x63, 0x0C, 'Q', '\0', 'u', '\0', 0xE9, '\0',
+                      'b', '\0', 'e', '\0', 'c', '\0'});
+  ASSERT_TRUE(value->IsString());
+  EXPECT_EQ(6, String::Cast(*value)->Length());
+  EXPECT_EQ(kQuebecString, Utf8Value(value));
+
+  value = DecodeTest({0xFF, 0x09, 0x63, 0x04, 0x3D, 0xD8, 0x4A, 0xDC});
+  ASSERT_TRUE(value->IsString());
+  EXPECT_EQ(2, String::Cast(*value)->Length());
+  EXPECT_EQ(kEmojiString, Utf8Value(value));
 #endif
   // TODO(jbroman): The same for big-endian systems.
 }
@@ -543,152 +497,124 @@ TEST_F(ValueSerializerTest, EncodeTwoByteStringUsesPadding) {
   // As long as the output has a version that Blink expects to be able to read,
   // we must respect its alignment requirements. It requires that two-byte
   // characters be aligned.
-  EncodeTest(
-      [this]() {
-        // We need a string whose length will take two bytes to encode, so that
-        // a padding byte is needed to keep the characters aligned. The string
-        // must also have a two-byte character, so that it gets the two-byte
-        // encoding.
-        std::string string(200, ' ');
-        string += kEmojiString;
-        return StringFromUtf8(string.c_str());
-      },
-      [](const std::vector<uint8_t>& data) {
-        // This is a sufficient but not necessary condition. This test assumes
-        // that the wire format version is one byte long, but is flexible to
-        // what that value may be.
-        const uint8_t expected_prefix[] = {0x00, 0x63, 0x94, 0x03};
-        ASSERT_GT(data.size(), sizeof(expected_prefix) + 2);
-        EXPECT_EQ(0xFF, data[0]);
-        EXPECT_GE(data[1], 0x09);
-        EXPECT_LE(data[1], 0x7F);
-        EXPECT_TRUE(std::equal(std::begin(expected_prefix),
-                               std::end(expected_prefix), data.begin() + 2));
-      });
+  // We need a string whose length will take two bytes to encode, so that
+  // a padding byte is needed to keep the characters aligned. The string
+  // must also have a two-byte character, so that it gets the two-byte
+  // encoding.
+  std::string string(200, ' ');
+  string += kEmojiString;
+  const std::vector<uint8_t> data = EncodeTest(StringFromUtf8(string.c_str()));
+  // This is a sufficient but not necessary condition. This test assumes
+  // that the wire format version is one byte long, but is flexible to
+  // what that value may be.
+  const uint8_t expected_prefix[] = {0x00, 0x63, 0x94, 0x03};
+  ASSERT_GT(data.size(), sizeof(expected_prefix) + 2);
+  EXPECT_EQ(0xFF, data[0]);
+  EXPECT_GE(data[1], 0x09);
+  EXPECT_LE(data[1], 0x7F);
+  EXPECT_TRUE(std::equal(std::begin(expected_prefix), std::end(expected_prefix),
+                         data.begin() + 2));
 }
 
 TEST_F(ValueSerializerTest, RoundTripDictionaryObject) {
   // Empty object.
-  RoundTripTest("({})", [this](Local<Value> value) {
-    ASSERT_TRUE(value->IsObject());
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "Object.getPrototypeOf(result) === Object.prototype"));
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "Object.getOwnPropertyNames(result).length === 0"));
-  });
+  Local<Value> value = RoundTripTest("({})");
+  ASSERT_TRUE(value->IsObject());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Object.prototype");
+  ExpectScriptTrue("Object.getOwnPropertyNames(result).length === 0");
+
   // String key.
-  RoundTripTest("({ a: 42 })", [this](Local<Value> value) {
-    ASSERT_TRUE(value->IsObject());
-    EXPECT_TRUE(EvaluateScriptForResultBool("result.hasOwnProperty('a')"));
-    EXPECT_TRUE(EvaluateScriptForResultBool("result.a === 42"));
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "Object.getOwnPropertyNames(result).length === 1"));
-  });
+  value = RoundTripTest("({ a: 42 })");
+  ASSERT_TRUE(value->IsObject());
+  ExpectScriptTrue("result.hasOwnProperty('a')");
+  ExpectScriptTrue("result.a === 42");
+  ExpectScriptTrue("Object.getOwnPropertyNames(result).length === 1");
+
   // Integer key (treated as a string, but may be encoded differently).
-  RoundTripTest("({ 42: 'a' })", [this](Local<Value> value) {
-    ASSERT_TRUE(value->IsObject());
-    EXPECT_TRUE(EvaluateScriptForResultBool("result.hasOwnProperty('42')"));
-    EXPECT_TRUE(EvaluateScriptForResultBool("result[42] === 'a'"));
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "Object.getOwnPropertyNames(result).length === 1"));
-  });
+  value = RoundTripTest("({ 42: 'a' })");
+  ASSERT_TRUE(value->IsObject());
+  ExpectScriptTrue("result.hasOwnProperty('42')");
+  ExpectScriptTrue("result[42] === 'a'");
+  ExpectScriptTrue("Object.getOwnPropertyNames(result).length === 1");
+
   // Key order must be preserved.
-  RoundTripTest("({ x: 1, y: 2, a: 3 })", [this](Local<Value> value) {
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "Object.getOwnPropertyNames(result).toString() === 'x,y,a'"));
-  });
+  value = RoundTripTest("({ x: 1, y: 2, a: 3 })");
+  ExpectScriptTrue("Object.getOwnPropertyNames(result).toString() === 'x,y,a'");
+
   // A harder case of enumeration order.
   // Indexes first, in order (but not 2^32 - 1, which is not an index), then the
   // remaining (string) keys, in the order they were defined.
-  RoundTripTest(
-      "({ a: 2, 0xFFFFFFFF: 1, 0xFFFFFFFE: 3, 1: 0 })",
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getOwnPropertyNames(result).toString() === "
-            "'1,4294967294,a,4294967295'"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === 2"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[0xFFFFFFFF] === 1"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[0xFFFFFFFE] === 3"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[1] === 0"));
-      });
+  value = RoundTripTest("({ a: 2, 0xFFFFFFFF: 1, 0xFFFFFFFE: 3, 1: 0 })");
+  ExpectScriptTrue(
+      "Object.getOwnPropertyNames(result).toString() === "
+      "'1,4294967294,a,4294967295'");
+  ExpectScriptTrue("result.a === 2");
+  ExpectScriptTrue("result[0xFFFFFFFF] === 1");
+  ExpectScriptTrue("result[0xFFFFFFFE] === 3");
+  ExpectScriptTrue("result[1] === 0");
+
   // This detects a fairly subtle case: the object itself must be in the map
   // before its properties are deserialized, so that references to it can be
   // resolved.
-  RoundTripTest(
-      "(() => { var y = {}; y.self = y; return y; })()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsObject());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result === result.self"));
-      });
+  value = RoundTripTest("var y = {}; y.self = y; y;");
+  ASSERT_TRUE(value->IsObject());
+  ExpectScriptTrue("result === result.self");
 }
 
 TEST_F(ValueSerializerTest, DecodeDictionaryObject) {
   // Empty object.
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x7B, 0x00, 0x00},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsObject());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === Object.prototype"));
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getOwnPropertyNames(result).length === 0"));
-             });
+  Local<Value> value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x7B, 0x00, 0x00});
+  ASSERT_TRUE(value->IsObject());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Object.prototype");
+  ExpectScriptTrue("Object.getOwnPropertyNames(result).length === 0");
+
   // String key.
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x53, 0x01, 0x61, 0x3F, 0x01,
-       0x49, 0x54, 0x7B, 0x01},
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsObject());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.hasOwnProperty('a')"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === 42"));
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getOwnPropertyNames(result).length === 1"));
-      });
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x53, 0x01,
+                      0x61, 0x3F, 0x01, 0x49, 0x54, 0x7B, 0x01});
+  ASSERT_TRUE(value->IsObject());
+  ExpectScriptTrue("result.hasOwnProperty('a')");
+  ExpectScriptTrue("result.a === 42");
+  ExpectScriptTrue("Object.getOwnPropertyNames(result).length === 1");
+
   // Integer key (treated as a string, but may be encoded differently).
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x49, 0x54, 0x3F, 0x01, 0x53,
-       0x01, 0x61, 0x7B, 0x01},
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsObject());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.hasOwnProperty('42')"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[42] === 'a'"));
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getOwnPropertyNames(result).length === 1"));
-      });
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x49, 0x54,
+                      0x3F, 0x01, 0x53, 0x01, 0x61, 0x7B, 0x01});
+  ASSERT_TRUE(value->IsObject());
+  ExpectScriptTrue("result.hasOwnProperty('42')");
+  ExpectScriptTrue("result[42] === 'a'");
+  ExpectScriptTrue("Object.getOwnPropertyNames(result).length === 1");
+
   // Key order must be preserved.
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x53, 0x01, 0x78, 0x3F, 0x01,
-       0x49, 0x02, 0x3F, 0x01, 0x53, 0x01, 0x79, 0x3F, 0x01, 0x49, 0x04, 0x3F,
-       0x01, 0x53, 0x01, 0x61, 0x3F, 0x01, 0x49, 0x06, 0x7B, 0x03},
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getOwnPropertyNames(result).toString() === 'x,y,a'"));
-      });
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x53, 0x01,
+                      0x78, 0x3F, 0x01, 0x49, 0x02, 0x3F, 0x01, 0x53, 0x01,
+                      0x79, 0x3F, 0x01, 0x49, 0x04, 0x3F, 0x01, 0x53, 0x01,
+                      0x61, 0x3F, 0x01, 0x49, 0x06, 0x7B, 0x03});
+  ExpectScriptTrue("Object.getOwnPropertyNames(result).toString() === 'x,y,a'");
+
   // A harder case of enumeration order.
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x49, 0x02, 0x3F, 0x01,
-       0x49, 0x00, 0x3F, 0x01, 0x55, 0xFE, 0xFF, 0xFF, 0xFF, 0x0F, 0x3F,
-       0x01, 0x49, 0x06, 0x3F, 0x01, 0x53, 0x01, 0x61, 0x3F, 0x01, 0x49,
-       0x04, 0x3F, 0x01, 0x53, 0x0A, 0x34, 0x32, 0x39, 0x34, 0x39, 0x36,
-       0x37, 0x32, 0x39, 0x35, 0x3F, 0x01, 0x49, 0x02, 0x7B, 0x04},
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getOwnPropertyNames(result).toString() === "
-            "'1,4294967294,a,4294967295'"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === 2"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[0xFFFFFFFF] === 1"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[0xFFFFFFFE] === 3"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[1] === 0"));
-      });
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x49, 0x02,
+                      0x3F, 0x01, 0x49, 0x00, 0x3F, 0x01, 0x55, 0xFE, 0xFF,
+                      0xFF, 0xFF, 0x0F, 0x3F, 0x01, 0x49, 0x06, 0x3F, 0x01,
+                      0x53, 0x01, 0x61, 0x3F, 0x01, 0x49, 0x04, 0x3F, 0x01,
+                      0x53, 0x0A, 0x34, 0x32, 0x39, 0x34, 0x39, 0x36, 0x37,
+                      0x32, 0x39, 0x35, 0x3F, 0x01, 0x49, 0x02, 0x7B, 0x04});
+  ExpectScriptTrue(
+      "Object.getOwnPropertyNames(result).toString() === "
+      "'1,4294967294,a,4294967295'");
+  ExpectScriptTrue("result.a === 2");
+  ExpectScriptTrue("result[0xFFFFFFFF] === 1");
+  ExpectScriptTrue("result[0xFFFFFFFE] === 3");
+  ExpectScriptTrue("result[1] === 0");
+
   // This detects a fairly subtle case: the object itself must be in the map
   // before its properties are deserialized, so that references to it can be
   // resolved.
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x53, 0x04, 0x73,
-       0x65, 0x6C, 0x66, 0x3F, 0x01, 0x5E, 0x00, 0x7B, 0x01, 0x00},
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsObject());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result === result.self"));
-      });
+  value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x53, 0x04, 0x73,
+                  0x65, 0x6C, 0x66, 0x3F, 0x01, 0x5E, 0x00, 0x7B, 0x01, 0x00});
+  ASSERT_TRUE(value->IsObject());
+  ExpectScriptTrue("result === result.self");
 }
 
 TEST_F(ValueSerializerTest, InvalidDecodeObjectWithInvalidKeyType) {
@@ -701,89 +627,72 @@ TEST_F(ValueSerializerTest, InvalidDecodeObjectWithInvalidKeyType) {
 
 TEST_F(ValueSerializerTest, RoundTripOnlyOwnEnumerableStringKeys) {
   // Only "own" properties should be serialized, not ones on the prototype.
-  RoundTripTest("(() => { var x = {}; x.__proto__ = {a: 4}; return x; })()",
-                [this](Local<Value> value) {
-                  EXPECT_TRUE(EvaluateScriptForResultBool("!('a' in result)"));
-                });
+  Local<Value> value = RoundTripTest("var x = {}; x.__proto__ = {a: 4}; x;");
+  ExpectScriptTrue("!('a' in result)");
+
   // Only enumerable properties should be serialized.
-  RoundTripTest(
-      "(() => {"
-      "  var x = {};"
-      "  Object.defineProperty(x, 'a', {value: 1, enumerable: false});"
-      "  return x;"
-      "})()",
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool("!('a' in result)"));
-      });
+  value = RoundTripTest(
+      "var x = {};"
+      "Object.defineProperty(x, 'a', {value: 1, enumerable: false});"
+      "x;");
+  ExpectScriptTrue("!('a' in result)");
+
   // Symbol keys should not be serialized.
-  RoundTripTest("({ [Symbol()]: 4 })", [this](Local<Value> value) {
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "Object.getOwnPropertySymbols(result).length === 0"));
-  });
+  value = RoundTripTest("({ [Symbol()]: 4 })");
+  ExpectScriptTrue("Object.getOwnPropertySymbols(result).length === 0");
 }
 
 TEST_F(ValueSerializerTest, RoundTripTrickyGetters) {
   // Keys are enumerated before any setters are called, but if there is no own
   // property when the value is to be read, then it should not be serialized.
-  RoundTripTest("({ get a() { delete this.b; return 1; }, b: 2 })",
-                [this](Local<Value> value) {
-                  EXPECT_TRUE(EvaluateScriptForResultBool("!('b' in result)"));
-                });
+  Local<Value> value =
+      RoundTripTest("({ get a() { delete this.b; return 1; }, b: 2 })");
+  ExpectScriptTrue("!('b' in result)");
+
   // Keys added after the property enumeration should not be serialized.
-  RoundTripTest("({ get a() { this.b = 3; }})", [this](Local<Value> value) {
-    EXPECT_TRUE(EvaluateScriptForResultBool("!('b' in result)"));
-  });
+  value = RoundTripTest("({ get a() { this.b = 3; }})");
+  ExpectScriptTrue("!('b' in result)");
+
   // But if you remove a key and add it back, that's fine. But it will appear in
   // the original place in enumeration order.
-  RoundTripTest(
-      "({ get a() { delete this.b; this.b = 4; }, b: 2, c: 3 })",
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getOwnPropertyNames(result).toString() === 'a,b,c'"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.b === 4"));
-      });
+  value =
+      RoundTripTest("({ get a() { delete this.b; this.b = 4; }, b: 2, c: 3 })");
+  ExpectScriptTrue("Object.getOwnPropertyNames(result).toString() === 'a,b,c'");
+  ExpectScriptTrue("result.b === 4");
+
   // Similarly, it only matters if a property was enumerable when the
   // enumeration happened.
-  RoundTripTest(
+  value = RoundTripTest(
       "({ get a() {"
       "    Object.defineProperty(this, 'b', {value: 2, enumerable: false});"
-      "}, b: 1})",
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.b === 2"));
-      });
-  RoundTripTest(
-      "(() => {"
-      "  var x = {"
-      "    get a() {"
-      "      Object.defineProperty(this, 'b', {value: 2, enumerable: true});"
-      "    }"
-      "  };"
-      "  Object.defineProperty(x, 'b',"
-      "      {value: 1, enumerable: false, configurable: true});"
-      "  return x;"
-      "})()",
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool("!('b' in result)"));
-      });
+      "}, b: 1})");
+  ExpectScriptTrue("result.b === 2");
+
+  value = RoundTripTest(
+      "var x = {"
+      "  get a() {"
+      "    Object.defineProperty(this, 'b', {value: 2, enumerable: true});"
+      "  }"
+      "};"
+      "Object.defineProperty(x, 'b',"
+      "    {value: 1, enumerable: false, configurable: true});"
+      "x;");
+  ExpectScriptTrue("!('b' in result)");
+
   // The property also should not be read if it can only be found on the
   // prototype chain (but not as an own property) after enumeration.
-  RoundTripTest(
-      "(() => {"
-      "  var x = { get a() { delete this.b; }, b: 1 };"
-      "  x.__proto__ = { b: 0 };"
-      "  return x;"
-      "})()",
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool("!('b' in result)"));
-      });
+  value = RoundTripTest(
+      "var x = { get a() { delete this.b; }, b: 1 };"
+      "x.__proto__ = { b: 0 };"
+      "x;");
+  ExpectScriptTrue("!('b' in result)");
+
   // If an exception is thrown by script, encoding must fail and the exception
   // must be thrown.
-  InvalidEncodeTest("({ get a() { throw new Error('sentinel'); } })",
-                    [this](Local<Message> message) {
-                      ASSERT_FALSE(message.IsEmpty());
-                      EXPECT_NE(std::string::npos,
-                                Utf8Value(message->Get()).find("sentinel"));
-                    });
+  Local<Message> message =
+      InvalidEncodeTest("({ get a() { throw new Error('sentinel'); } })");
+  ASSERT_FALSE(message.IsEmpty());
+  EXPECT_NE(std::string::npos, Utf8Value(message->Get()).find("sentinel"));
 }
 
 TEST_F(ValueSerializerTest, RoundTripDictionaryObjectForTransitions) {
@@ -813,234 +722,186 @@ TEST_F(ValueSerializerTest, RoundTripDictionaryObjectForTransitions) {
 
 TEST_F(ValueSerializerTest, DecodeDictionaryObjectVersion0) {
   // Empty object.
-  DecodeTestForVersion0(
-      {0x7B, 0x00}, [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsObject());
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getPrototypeOf(result) === Object.prototype"));
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getOwnPropertyNames(result).length === 0"));
-      });
+  Local<Value> value = DecodeTestForVersion0({0x7B, 0x00});
+  ASSERT_TRUE(value->IsObject());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Object.prototype");
+  ExpectScriptTrue("Object.getOwnPropertyNames(result).length === 0");
+
   // String key.
-  DecodeTestForVersion0(
-      {0x53, 0x01, 0x61, 0x49, 0x54, 0x7B, 0x01, 0x00},
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsObject());
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getPrototypeOf(result) === Object.prototype"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.hasOwnProperty('a')"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === 42"));
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getOwnPropertyNames(result).length === 1"));
-      });
+  value =
+      DecodeTestForVersion0({0x53, 0x01, 0x61, 0x49, 0x54, 0x7B, 0x01, 0x00});
+  ASSERT_TRUE(value->IsObject());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Object.prototype");
+  ExpectScriptTrue("result.hasOwnProperty('a')");
+  ExpectScriptTrue("result.a === 42");
+  ExpectScriptTrue("Object.getOwnPropertyNames(result).length === 1");
+
   // Integer key (treated as a string, but may be encoded differently).
-  DecodeTestForVersion0(
-      {0x49, 0x54, 0x53, 0x01, 0x61, 0x7B, 0x01, 0x00},
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsObject());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.hasOwnProperty('42')"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[42] === 'a'"));
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getOwnPropertyNames(result).length === 1"));
-      });
+  value =
+      DecodeTestForVersion0({0x49, 0x54, 0x53, 0x01, 0x61, 0x7B, 0x01, 0x00});
+  ASSERT_TRUE(value->IsObject());
+  ExpectScriptTrue("result.hasOwnProperty('42')");
+  ExpectScriptTrue("result[42] === 'a'");
+  ExpectScriptTrue("Object.getOwnPropertyNames(result).length === 1");
+
   // Key order must be preserved.
-  DecodeTestForVersion0(
-      {0x53, 0x01, 0x78, 0x49, 0x02, 0x53, 0x01, 0x79, 0x49, 0x04, 0x53, 0x01,
-       0x61, 0x49, 0x06, 0x7B, 0x03, 0x00},
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getOwnPropertyNames(result).toString() === 'x,y,a'"));
-      });
+  value = DecodeTestForVersion0({0x53, 0x01, 0x78, 0x49, 0x02, 0x53, 0x01, 0x79,
+                                 0x49, 0x04, 0x53, 0x01, 0x61, 0x49, 0x06, 0x7B,
+                                 0x03, 0x00});
+  ExpectScriptTrue("Object.getOwnPropertyNames(result).toString() === 'x,y,a'");
+
   // A property and an element.
-  DecodeTestForVersion0(
-      {0x49, 0x54, 0x53, 0x01, 0x61, 0x53, 0x01, 0x61, 0x49, 0x54, 0x7B, 0x02},
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getOwnPropertyNames(result).toString() === '42,a'"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[42] === 'a'"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === 42"));
-      });
+  value = DecodeTestForVersion0(
+      {0x49, 0x54, 0x53, 0x01, 0x61, 0x53, 0x01, 0x61, 0x49, 0x54, 0x7B, 0x02});
+  ExpectScriptTrue("Object.getOwnPropertyNames(result).toString() === '42,a'");
+  ExpectScriptTrue("result[42] === 'a'");
+  ExpectScriptTrue("result.a === 42");
 }
 
 TEST_F(ValueSerializerTest, RoundTripArray) {
   // A simple array of integers.
-  RoundTripTest("[1, 2, 3, 4, 5]", [this](Local<Value> value) {
-    ASSERT_TRUE(value->IsArray());
-    EXPECT_EQ(5u, Array::Cast(*value)->Length());
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "Object.getPrototypeOf(result) === Array.prototype"));
-    EXPECT_TRUE(
-        EvaluateScriptForResultBool("result.toString() === '1,2,3,4,5'"));
-  });
+  Local<Value> value = RoundTripTest("[1, 2, 3, 4, 5]");
+  ASSERT_TRUE(value->IsArray());
+  EXPECT_EQ(5u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Array.prototype");
+  ExpectScriptTrue("result.toString() === '1,2,3,4,5'");
+
   // A long (sparse) array.
-  RoundTripTest(
-      "(() => { var x = new Array(1000); x[500] = 42; return x; })()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        EXPECT_EQ(1000u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[500] === 42"));
-      });
+  value = RoundTripTest("var x = new Array(1000); x[500] = 42; x;");
+  ASSERT_TRUE(value->IsArray());
+  EXPECT_EQ(1000u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result[500] === 42");
+
   // Duplicate reference.
-  RoundTripTest(
-      "(() => { var y = {}; return [y, y]; })()", [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(2u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[0] === result[1]"));
-      });
+  value = RoundTripTest("var y = {}; [y, y];");
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(2u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result[0] === result[1]");
+
   // Duplicate reference in a sparse array.
-  RoundTripTest(
-      "(() => { var x = new Array(1000); x[1] = x[500] = {}; return x; })()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(1000u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(
-            EvaluateScriptForResultBool("typeof result[1] === 'object'"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[1] === result[500]"));
-      });
+  value = RoundTripTest("var x = new Array(1000); x[1] = x[500] = {}; x;");
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(1000u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("typeof result[1] === 'object'");
+  ExpectScriptTrue("result[1] === result[500]");
+
   // Self reference.
-  RoundTripTest(
-      "(() => { var y = []; y[0] = y; return y; })()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(1u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[0] === result"));
-      });
+  value = RoundTripTest("var y = []; y[0] = y; y;");
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(1u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result[0] === result");
+
   // Self reference in a sparse array.
-  RoundTripTest(
-      "(() => { var y = new Array(1000); y[519] = y; return y; })()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(1000u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[519] === result"));
-      });
+  value = RoundTripTest("var y = new Array(1000); y[519] = y; y;");
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(1000u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result[519] === result");
+
   // Array with additional properties.
-  RoundTripTest(
-      "(() => { var y = [1, 2]; y.foo = 'bar'; return y; })()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(2u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.toString() === '1,2'"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.foo === 'bar'"));
-      });
+  value = RoundTripTest("var y = [1, 2]; y.foo = 'bar'; y;");
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(2u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result.toString() === '1,2'");
+  ExpectScriptTrue("result.foo === 'bar'");
+
   // Sparse array with additional properties.
-  RoundTripTest(
-      "(() => { var y = new Array(1000); y.foo = 'bar'; return y; })()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(1000u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "result.toString() === ','.repeat(999)"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.foo === 'bar'"));
-      });
+  value = RoundTripTest("var y = new Array(1000); y.foo = 'bar'; y;");
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(1000u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result.toString() === ','.repeat(999)");
+  ExpectScriptTrue("result.foo === 'bar'");
+
   // The distinction between holes and undefined elements must be maintained.
-  RoundTripTest("[,undefined]", [this](Local<Value> value) {
-    ASSERT_TRUE(value->IsArray());
-    ASSERT_EQ(2u, Array::Cast(*value)->Length());
-    EXPECT_TRUE(
-        EvaluateScriptForResultBool("typeof result[0] === 'undefined'"));
-    EXPECT_TRUE(
-        EvaluateScriptForResultBool("typeof result[1] === 'undefined'"));
-    EXPECT_TRUE(EvaluateScriptForResultBool("!result.hasOwnProperty(0)"));
-    EXPECT_TRUE(EvaluateScriptForResultBool("result.hasOwnProperty(1)"));
-  });
+  value = RoundTripTest("[,undefined]");
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(2u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("typeof result[0] === 'undefined'");
+  ExpectScriptTrue("typeof result[1] === 'undefined'");
+  ExpectScriptTrue("!result.hasOwnProperty(0)");
+  ExpectScriptTrue("result.hasOwnProperty(1)");
 }
 
 TEST_F(ValueSerializerTest, DecodeArray) {
   // A simple array of integers.
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x41, 0x05, 0x3F, 0x01, 0x49, 0x02,
-              0x3F, 0x01, 0x49, 0x04, 0x3F, 0x01, 0x49, 0x06, 0x3F, 0x01,
-              0x49, 0x08, 0x3F, 0x01, 0x49, 0x0A, 0x24, 0x00, 0x05, 0x00},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsArray());
-               EXPECT_EQ(5u, Array::Cast(*value)->Length());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === Array.prototype"));
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "result.toString() === '1,2,3,4,5'"));
-             });
+  Local<Value> value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x41, 0x05, 0x3F, 0x01, 0x49, 0x02,
+                  0x3F, 0x01, 0x49, 0x04, 0x3F, 0x01, 0x49, 0x06, 0x3F, 0x01,
+                  0x49, 0x08, 0x3F, 0x01, 0x49, 0x0A, 0x24, 0x00, 0x05, 0x00});
+  ASSERT_TRUE(value->IsArray());
+  EXPECT_EQ(5u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Array.prototype");
+  ExpectScriptTrue("result.toString() === '1,2,3,4,5'");
+
   // A long (sparse) array.
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x61, 0xE8, 0x07, 0x3F, 0x01, 0x49,
-              0xE8, 0x07, 0x3F, 0x01, 0x49, 0x54, 0x40, 0x01, 0xE8, 0x07},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsArray());
-               EXPECT_EQ(1000u, Array::Cast(*value)->Length());
-               EXPECT_TRUE(EvaluateScriptForResultBool("result[500] === 42"));
-             });
+  value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x61, 0xE8, 0x07, 0x3F, 0x01, 0x49,
+                  0xE8, 0x07, 0x3F, 0x01, 0x49, 0x54, 0x40, 0x01, 0xE8, 0x07});
+  ASSERT_TRUE(value->IsArray());
+  EXPECT_EQ(1000u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result[500] === 42");
+
   // Duplicate reference.
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x41, 0x02, 0x3F, 0x01, 0x6F, 0x7B, 0x00, 0x3F,
-       0x02, 0x5E, 0x01, 0x24, 0x00, 0x02},
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(2u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[0] === result[1]"));
-      });
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x41, 0x02, 0x3F, 0x01, 0x6F,
+                      0x7B, 0x00, 0x3F, 0x02, 0x5E, 0x01, 0x24, 0x00, 0x02});
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(2u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result[0] === result[1]");
+
   // Duplicate reference in a sparse array.
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x61, 0xE8, 0x07, 0x3F, 0x01, 0x49,
-       0x02, 0x3F, 0x01, 0x6F, 0x7B, 0x00, 0x3F, 0x02, 0x49, 0xE8,
-       0x07, 0x3F, 0x02, 0x5E, 0x01, 0x40, 0x02, 0xE8, 0x07, 0x00},
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(1000u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(
-            EvaluateScriptForResultBool("typeof result[1] === 'object'"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[1] === result[500]"));
-      });
+  value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x61, 0xE8, 0x07, 0x3F, 0x01, 0x49,
+                  0x02, 0x3F, 0x01, 0x6F, 0x7B, 0x00, 0x3F, 0x02, 0x49, 0xE8,
+                  0x07, 0x3F, 0x02, 0x5E, 0x01, 0x40, 0x02, 0xE8, 0x07, 0x00});
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(1000u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("typeof result[1] === 'object'");
+  ExpectScriptTrue("result[1] === result[500]");
+
   // Self reference.
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x41, 0x01, 0x3F, 0x01, 0x5E, 0x00, 0x24,
-              0x00, 0x01, 0x00},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsArray());
-               ASSERT_EQ(1u, Array::Cast(*value)->Length());
-               EXPECT_TRUE(EvaluateScriptForResultBool("result[0] === result"));
-             });
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x41, 0x01, 0x3F, 0x01, 0x5E,
+                      0x00, 0x24, 0x00, 0x01, 0x00});
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(1u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result[0] === result");
+
   // Self reference in a sparse array.
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x61, 0xE8, 0x07, 0x3F, 0x01, 0x49,
-       0x8E, 0x08, 0x3F, 0x01, 0x5E, 0x00, 0x40, 0x01, 0xE8, 0x07},
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(1000u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[519] === result"));
-      });
+  value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x61, 0xE8, 0x07, 0x3F, 0x01, 0x49,
+                  0x8E, 0x08, 0x3F, 0x01, 0x5E, 0x00, 0x40, 0x01, 0xE8, 0x07});
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(1000u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result[519] === result");
+
   // Array with additional properties.
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x41, 0x02, 0x3F, 0x01, 0x49, 0x02, 0x3F,
-       0x01, 0x49, 0x04, 0x3F, 0x01, 0x53, 0x03, 0x66, 0x6F, 0x6F, 0x3F,
-       0x01, 0x53, 0x03, 0x62, 0x61, 0x72, 0x24, 0x01, 0x02, 0x00},
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(2u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.toString() === '1,2'"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.foo === 'bar'"));
-      });
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x41, 0x02, 0x3F, 0x01,
+                      0x49, 0x02, 0x3F, 0x01, 0x49, 0x04, 0x3F, 0x01,
+                      0x53, 0x03, 0x66, 0x6F, 0x6F, 0x3F, 0x01, 0x53,
+                      0x03, 0x62, 0x61, 0x72, 0x24, 0x01, 0x02, 0x00});
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(2u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result.toString() === '1,2'");
+  ExpectScriptTrue("result.foo === 'bar'");
+
   // Sparse array with additional properties.
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x61, 0xE8, 0x07, 0x3F, 0x01,
-              0x53, 0x03, 0x66, 0x6F, 0x6F, 0x3F, 0x01, 0x53, 0x03,
-              0x62, 0x61, 0x72, 0x40, 0x01, 0xE8, 0x07, 0x00},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsArray());
-               ASSERT_EQ(1000u, Array::Cast(*value)->Length());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "result.toString() === ','.repeat(999)"));
-               EXPECT_TRUE(EvaluateScriptForResultBool("result.foo === 'bar'"));
-             });
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x61, 0xE8, 0x07, 0x3F, 0x01,
+                      0x53, 0x03, 0x66, 0x6F, 0x6F, 0x3F, 0x01, 0x53, 0x03,
+                      0x62, 0x61, 0x72, 0x40, 0x01, 0xE8, 0x07, 0x00});
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(1000u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result.toString() === ','.repeat(999)");
+  ExpectScriptTrue("result.foo === 'bar'");
+
   // The distinction between holes and undefined elements must be maintained.
   // Note that since the previous output from Chrome fails this test, an
   // encoding using the sparse format was constructed instead.
-  DecodeTest(
-      {0xFF, 0x09, 0x61, 0x02, 0x49, 0x02, 0x5F, 0x40, 0x01, 0x02},
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(2u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(
-            EvaluateScriptForResultBool("typeof result[0] === 'undefined'"));
-        EXPECT_TRUE(
-            EvaluateScriptForResultBool("typeof result[1] === 'undefined'"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("!result.hasOwnProperty(0)"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.hasOwnProperty(1)"));
-      });
+  value =
+      DecodeTest({0xFF, 0x09, 0x61, 0x02, 0x49, 0x02, 0x5F, 0x40, 0x01, 0x02});
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(2u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("typeof result[0] === 'undefined'");
+  ExpectScriptTrue("typeof result[1] === 'undefined'");
+  ExpectScriptTrue("!result.hasOwnProperty(0)");
+  ExpectScriptTrue("result.hasOwnProperty(1)");
 }
 
 TEST_F(ValueSerializerTest, DecodeInvalidOverLargeArray) {
@@ -1055,375 +916,285 @@ TEST_F(ValueSerializerTest, RoundTripArrayWithNonEnumerableElement) {
   // Even though this array looks like [1,5,3], the 5 should be missing from the
   // perspective of structured clone, which only clones properties that were
   // enumerable.
-  RoundTripTest(
-      "(() => {"
-      "  var x = [1,2,3];"
-      "  Object.defineProperty(x, '1', {enumerable:false, value:5});"
-      "  return x;"
-      "})()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(3u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool("!result.hasOwnProperty('1')"));
-      });
+  Local<Value> value = RoundTripTest(
+      "var x = [1,2,3];"
+      "Object.defineProperty(x, '1', {enumerable:false, value:5});"
+      "x;");
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(3u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("!result.hasOwnProperty('1')");
 }
 
 TEST_F(ValueSerializerTest, RoundTripArrayWithTrickyGetters) {
   // If an element is deleted before it is serialized, then it's deleted.
-  RoundTripTest(
-      "(() => {"
-      "  var x = [{ get a() { delete x[1]; }}, 42];"
-      "  return x;"
-      "})()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(2u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(
-            EvaluateScriptForResultBool("typeof result[1] === 'undefined'"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("!result.hasOwnProperty(1)"));
-      });
+  Local<Value> value =
+      RoundTripTest("var x = [{ get a() { delete x[1]; }}, 42]; x;");
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(2u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("typeof result[1] === 'undefined'");
+  ExpectScriptTrue("!result.hasOwnProperty(1)");
+
   // Same for sparse arrays.
-  RoundTripTest(
-      "(() => {"
-      "  var x = [{ get a() { delete x[1]; }}, 42];"
-      "  x.length = 1000;"
-      "  return x;"
-      "})()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(1000u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(
-            EvaluateScriptForResultBool("typeof result[1] === 'undefined'"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("!result.hasOwnProperty(1)"));
-      });
+  value = RoundTripTest(
+      "var x = [{ get a() { delete x[1]; }}, 42];"
+      "x.length = 1000;"
+      "x;");
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(1000u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("typeof result[1] === 'undefined'");
+  ExpectScriptTrue("!result.hasOwnProperty(1)");
+
   // If the length is changed, then the resulting array still has the original
   // length, but elements that were not yet serialized are gone.
-  RoundTripTest(
-      "(() => {"
-      "  var x = [1, { get a() { x.length = 0; }}, 3, 4];"
-      "  return x;"
-      "})()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(4u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[0] === 1"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("!result.hasOwnProperty(2)"));
-      });
+  value = RoundTripTest("var x = [1, { get a() { x.length = 0; }}, 3, 4]; x;");
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(4u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result[0] === 1");
+  ExpectScriptTrue("!result.hasOwnProperty(2)");
+
   // The same is true if the length is shortened, but there are still items
   // remaining.
-  RoundTripTest(
-      "(() => {"
-      "  var x = [1, { get a() { x.length = 3; }}, 3, 4];"
-      "  return x;"
-      "})()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(4u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[2] === 3"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("!result.hasOwnProperty(3)"));
-      });
+  value = RoundTripTest("var x = [1, { get a() { x.length = 3; }}, 3, 4]; x;");
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(4u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result[2] === 3");
+  ExpectScriptTrue("!result.hasOwnProperty(3)");
+
   // Same for sparse arrays.
-  RoundTripTest(
-      "(() => {"
-      "  var x = [1, { get a() { x.length = 0; }}, 3, 4];"
-      "  x.length = 1000;"
-      "  return x;"
-      "})()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(1000u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[0] === 1"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("!result.hasOwnProperty(2)"));
-      });
-  RoundTripTest(
-      "(() => {"
-      "  var x = [1, { get a() { x.length = 3; }}, 3, 4];"
-      "  x.length = 1000;"
-      "  return x;"
-      "})()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(1000u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[2] === 3"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("!result.hasOwnProperty(3)"));
-      });
+  value = RoundTripTest(
+      "var x = [1, { get a() { x.length = 0; }}, 3, 4];"
+      "x.length = 1000;"
+      "x;");
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(1000u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result[0] === 1");
+  ExpectScriptTrue("!result.hasOwnProperty(2)");
+
+  value = RoundTripTest(
+      "var x = [1, { get a() { x.length = 3; }}, 3, 4];"
+      "x.length = 1000;"
+      "x;");
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(1000u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result[2] === 3");
+  ExpectScriptTrue("!result.hasOwnProperty(3)");
+
   // If a getter makes a property non-enumerable, it should still be enumerated
   // as enumeration happens once before getters are invoked.
-  RoundTripTest(
-      "(() => {"
-      "  var x = [{ get a() {"
-      "    Object.defineProperty(x, '1', { value: 3, enumerable: false });"
-      "  }}, 2];"
-      "  return x;"
-      "})()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(2u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[1] === 3"));
-      });
+  value = RoundTripTest(
+      "var x = [{ get a() {"
+      "  Object.defineProperty(x, '1', { value: 3, enumerable: false });"
+      "}}, 2];"
+      "x;");
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(2u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result[1] === 3");
+
   // Same for sparse arrays.
-  RoundTripTest(
-      "(() => {"
-      "  var x = [{ get a() {"
-      "    Object.defineProperty(x, '1', { value: 3, enumerable: false });"
-      "  }}, 2];"
-      "  x.length = 1000;"
-      "  return x;"
-      "})()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(1000u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[1] === 3"));
-      });
+  value = RoundTripTest(
+      "var x = [{ get a() {"
+      "  Object.defineProperty(x, '1', { value: 3, enumerable: false });"
+      "}}, 2];"
+      "x.length = 1000;"
+      "x;");
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(1000u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result[1] === 3");
+
   // Getters on the array itself must also run.
-  RoundTripTest(
-      "(() => {"
-      "  var x = [1, 2, 3];"
-      "  Object.defineProperty(x, '1', { enumerable: true, get: () => 4 });"
-      "  return x;"
-      "})()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(3u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[1] === 4"));
-      });
+  value = RoundTripTest(
+      "var x = [1, 2, 3];"
+      "Object.defineProperty(x, '1', { enumerable: true, get: () => 4 });"
+      "x;");
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(3u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result[1] === 4");
+
   // Same for sparse arrays.
-  RoundTripTest(
-      "(() => {"
-      "  var x = [1, 2, 3];"
-      "  Object.defineProperty(x, '1', { enumerable: true, get: () => 4 });"
-      "  x.length = 1000;"
-      "  return x;"
-      "})()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(1000u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[1] === 4"));
-      });
+  value = RoundTripTest(
+      "var x = [1, 2, 3];"
+      "Object.defineProperty(x, '1', { enumerable: true, get: () => 4 });"
+      "x.length = 1000;"
+      "x;");
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(1000u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result[1] === 4");
+
   // Even with a getter that deletes things, we don't read from the prototype.
-  RoundTripTest(
-      "(() => {"
-      "  var x = [{ get a() { delete x[1]; } }, 2];"
-      "  x.__proto__ = Object.create(Array.prototype, { 1: { value: 6 } });"
-      "  return x;"
-      "})()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(2u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool("!(1 in result)"));
-      });
+  value = RoundTripTest(
+      "var x = [{ get a() { delete x[1]; } }, 2];"
+      "x.__proto__ = Object.create(Array.prototype, { 1: { value: 6 } });"
+      "x;");
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(2u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("!(1 in result)");
+
   // Same for sparse arrays.
-  RoundTripTest(
-      "(() => {"
-      "  var x = [{ get a() { delete x[1]; } }, 2];"
-      "  x.__proto__ = Object.create(Array.prototype, { 1: { value: 6 } });"
-      "  x.length = 1000;"
-      "  return x;"
-      "})()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        ASSERT_EQ(1000u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool("!(1 in result)"));
-      });
+  value = RoundTripTest(
+      "var x = [{ get a() { delete x[1]; } }, 2];"
+      "x.__proto__ = Object.create(Array.prototype, { 1: { value: 6 } });"
+      "x.length = 1000;"
+      "x;");
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(1000u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("!(1 in result)");
 }
 
 TEST_F(ValueSerializerTest, DecodeSparseArrayVersion0) {
   // Empty (sparse) array.
-  DecodeTestForVersion0({0x40, 0x00, 0x00, 0x00},
-                        [](Local<Value> value) {
-                          ASSERT_TRUE(value->IsArray());
-                          ASSERT_EQ(0u, Array::Cast(*value)->Length());
-                        });
+  Local<Value> value = DecodeTestForVersion0({0x40, 0x00, 0x00, 0x00});
+  ASSERT_TRUE(value->IsArray());
+  ASSERT_EQ(0u, Array::Cast(*value)->Length());
+
   // Sparse array with a mixture of elements and properties.
-  DecodeTestForVersion0(
-      {0x55, 0x00, 0x53, 0x01, 'a',  0x55, 0x02, 0x55, 0x05, 0x53,
-       0x03, 'f',  'o',  'o',  0x53, 0x03, 'b',  'a',  'r',  0x53,
-       0x03, 'b',  'a',  'z',  0x49, 0x0B, 0x40, 0x04, 0x03, 0x00},
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        EXPECT_EQ(3u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(
-            EvaluateScriptForResultBool("result.toString() === 'a,,5'"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("!(1 in result)"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.foo === 'bar'"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.baz === -6"));
-      });
+  value = DecodeTestForVersion0({0x55, 0x00, 0x53, 0x01, 'a',  0x55, 0x02, 0x55,
+                                 0x05, 0x53, 0x03, 'f',  'o',  'o',  0x53, 0x03,
+                                 'b',  'a',  'r',  0x53, 0x03, 'b',  'a',  'z',
+                                 0x49, 0x0B, 0x40, 0x04, 0x03, 0x00});
+  ASSERT_TRUE(value->IsArray());
+  EXPECT_EQ(3u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result.toString() === 'a,,5'");
+  ExpectScriptTrue("!(1 in result)");
+  ExpectScriptTrue("result.foo === 'bar'");
+  ExpectScriptTrue("result.baz === -6");
+
   // Sparse array in a sparse array (sanity check of nesting).
-  DecodeTestForVersion0(
-      {0x55, 0x01, 0x55, 0x01, 0x54, 0x40, 0x01, 0x02, 0x40, 0x01, 0x02, 0x00},
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsArray());
-        EXPECT_EQ(2u, Array::Cast(*value)->Length());
-        EXPECT_TRUE(EvaluateScriptForResultBool("!(0 in result)"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[1] instanceof Array"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("!(0 in result[1])"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[1][1] === true"));
-      });
+  value = DecodeTestForVersion0(
+      {0x55, 0x01, 0x55, 0x01, 0x54, 0x40, 0x01, 0x02, 0x40, 0x01, 0x02, 0x00});
+  ASSERT_TRUE(value->IsArray());
+  EXPECT_EQ(2u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("!(0 in result)");
+  ExpectScriptTrue("result[1] instanceof Array");
+  ExpectScriptTrue("!(0 in result[1])");
+  ExpectScriptTrue("result[1][1] === true");
 }
 
 TEST_F(ValueSerializerTest, RoundTripDenseArrayContainingUndefined) {
   // In previous serialization versions, this would be interpreted as an absent
   // property.
-  RoundTripTest("[undefined]", [this](Local<Value> value) {
-    ASSERT_TRUE(value->IsArray());
-    EXPECT_EQ(1u, Array::Cast(*value)->Length());
-    EXPECT_TRUE(EvaluateScriptForResultBool("result.hasOwnProperty(0)"));
-    EXPECT_TRUE(EvaluateScriptForResultBool("result[0] === undefined"));
-  });
+  Local<Value> value = RoundTripTest("[undefined]");
+  ASSERT_TRUE(value->IsArray());
+  EXPECT_EQ(1u, Array::Cast(*value)->Length());
+  ExpectScriptTrue("result.hasOwnProperty(0)");
+  ExpectScriptTrue("result[0] === undefined");
 }
 
 TEST_F(ValueSerializerTest, DecodeDenseArrayContainingUndefined) {
   // In previous versions, "undefined" in a dense array signified absence of the
   // element (for compatibility). In new versions, it has a separate encoding.
-  DecodeTest({0xFF, 0x09, 0x41, 0x01, 0x5F, 0x24, 0x00, 0x01},
-             [this](Local<Value> value) {
-               EXPECT_TRUE(EvaluateScriptForResultBool("!(0 in result)"));
-             });
-  DecodeTest(
-      {0xFF, 0x0B, 0x41, 0x01, 0x5F, 0x24, 0x00, 0x01},
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool("0 in result"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result[0] === undefined"));
-      });
-  DecodeTest({0xFF, 0x0B, 0x41, 0x01, 0x2D, 0x24, 0x00, 0x01},
-             [this](Local<Value> value) {
-               EXPECT_TRUE(EvaluateScriptForResultBool("!(0 in result)"));
-             });
+  Local<Value> value =
+      DecodeTest({0xFF, 0x09, 0x41, 0x01, 0x5F, 0x24, 0x00, 0x01});
+  ExpectScriptTrue("!(0 in result)");
+
+  value = DecodeTest({0xFF, 0x0B, 0x41, 0x01, 0x5F, 0x24, 0x00, 0x01});
+  ExpectScriptTrue("0 in result");
+  ExpectScriptTrue("result[0] === undefined");
+
+  value = DecodeTest({0xFF, 0x0B, 0x41, 0x01, 0x2D, 0x24, 0x00, 0x01});
+  ExpectScriptTrue("!(0 in result)");
 }
 
 TEST_F(ValueSerializerTest, RoundTripDate) {
-  RoundTripTest("new Date(1e6)", [this](Local<Value> value) {
-    ASSERT_TRUE(value->IsDate());
-    EXPECT_EQ(1e6, Date::Cast(*value)->ValueOf());
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "Object.getPrototypeOf(result) === Date.prototype"));
-  });
-  RoundTripTest("new Date(Date.UTC(1867, 6, 1))", [this](Local<Value> value) {
-    ASSERT_TRUE(value->IsDate());
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "result.toISOString() === '1867-07-01T00:00:00.000Z'"));
-  });
-  RoundTripTest("new Date(NaN)", [](Local<Value> value) {
-    ASSERT_TRUE(value->IsDate());
-    EXPECT_TRUE(std::isnan(Date::Cast(*value)->ValueOf()));
-  });
-  RoundTripTest(
-      "({ a: new Date(), get b() { return this.a; } })",
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a instanceof Date"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === result.b"));
-      });
+  Local<Value> value = RoundTripTest("new Date(1e6)");
+  ASSERT_TRUE(value->IsDate());
+  EXPECT_EQ(1e6, Date::Cast(*value)->ValueOf());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Date.prototype");
+
+  value = RoundTripTest("new Date(Date.UTC(1867, 6, 1))");
+  ASSERT_TRUE(value->IsDate());
+  ExpectScriptTrue("result.toISOString() === '1867-07-01T00:00:00.000Z'");
+
+  value = RoundTripTest("new Date(NaN)");
+  ASSERT_TRUE(value->IsDate());
+  EXPECT_TRUE(std::isnan(Date::Cast(*value)->ValueOf()));
+
+  value = RoundTripTest("({ a: new Date(), get b() { return this.a; } })");
+  ExpectScriptTrue("result.a instanceof Date");
+  ExpectScriptTrue("result.a === result.b");
 }
 
 TEST_F(ValueSerializerTest, DecodeDate) {
+  Local<Value> value;
 #if defined(V8_TARGET_LITTLE_ENDIAN)
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x44, 0x00, 0x00, 0x00, 0x00, 0x80, 0x84,
-              0x2E, 0x41, 0x00},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsDate());
-               EXPECT_EQ(1e6, Date::Cast(*value)->ValueOf());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === Date.prototype"));
-             });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x44, 0x00, 0x00, 0x20, 0x45, 0x27, 0x89,
-              0x87, 0xC2, 0x00},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsDate());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "result.toISOString() === '1867-07-01T00:00:00.000Z'"));
-             });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-              0xF8, 0x7F, 0x00},
-             [](Local<Value> value) {
-               ASSERT_TRUE(value->IsDate());
-               EXPECT_TRUE(std::isnan(Date::Cast(*value)->ValueOf()));
-             });
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x44, 0x00, 0x00, 0x00, 0x00,
+                      0x80, 0x84, 0x2E, 0x41, 0x00});
+  ASSERT_TRUE(value->IsDate());
+  EXPECT_EQ(1e6, Date::Cast(*value)->ValueOf());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Date.prototype");
+
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x44, 0x00, 0x00, 0x20, 0x45,
+                      0x27, 0x89, 0x87, 0xC2, 0x00});
+  ASSERT_TRUE(value->IsDate());
+  ExpectScriptTrue("result.toISOString() === '1867-07-01T00:00:00.000Z'");
+
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x44, 0x00, 0x00, 0x00, 0x00,
+                      0x00, 0x00, 0xF8, 0x7F, 0x00});
+  ASSERT_TRUE(value->IsDate());
+  EXPECT_TRUE(std::isnan(Date::Cast(*value)->ValueOf()));
 #else
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x44, 0x41, 0x2E, 0x84, 0x80, 0x00, 0x00,
-              0x00, 0x00, 0x00},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsDate());
-               EXPECT_EQ(1e6, Date::Cast(*value)->ValueOf());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === Date.prototype"));
-             });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x44, 0xC2, 0x87, 0x89, 0x27, 0x45, 0x20,
-              0x00, 0x00, 0x00},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsDate());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "result.toISOString() === '1867-07-01T00:00:00.000Z'"));
-             });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x44, 0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00,
-              0x00, 0x00, 0x00},
-             [](Local<Value> value) {
-               ASSERT_TRUE(value->IsDate());
-               EXPECT_TRUE(std::isnan(Date::Cast(*value)->ValueOf()));
-             });
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x44, 0x41, 0x2E, 0x84, 0x80,
+                      0x00, 0x00, 0x00, 0x00, 0x00});
+  ASSERT_TRUE(value->IsDate());
+  EXPECT_EQ(1e6, Date::Cast(*value)->ValueOf());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Date.prototype");
+
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x44, 0xC2, 0x87, 0x89, 0x27,
+                      0x45, 0x20, 0x00, 0x00, 0x00});
+  ASSERT_TRUE(value->IsDate());
+  ExpectScriptTrue("result.toISOString() === '1867-07-01T00:00:00.000Z'");
+
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x44, 0x7F, 0xF8, 0x00, 0x00,
+                      0x00, 0x00, 0x00, 0x00, 0x00});
+  ASSERT_TRUE(value->IsDate());
+  EXPECT_TRUE(std::isnan(Date::Cast(*value)->ValueOf()));
 #endif
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x53, 0x01, 0x61, 0x3F,
-       0x01, 0x44, 0x00, 0x20, 0x39, 0x50, 0x37, 0x6A, 0x75, 0x42, 0x3F,
-       0x02, 0x53, 0x01, 0x62, 0x3F, 0x02, 0x5E, 0x01, 0x7B, 0x02},
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a instanceof Date"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === result.b"));
-      });
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x53,
+                      0x01, 0x61, 0x3F, 0x01, 0x44, 0x00, 0x20, 0x39,
+                      0x50, 0x37, 0x6A, 0x75, 0x42, 0x3F, 0x02, 0x53,
+                      0x01, 0x62, 0x3F, 0x02, 0x5E, 0x01, 0x7B, 0x02});
+  ExpectScriptTrue("result.a instanceof Date");
+  ExpectScriptTrue("result.a === result.b");
 }
 
 TEST_F(ValueSerializerTest, RoundTripValueObjects) {
-  RoundTripTest("new Boolean(true)", [this](Local<Value> value) {
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "Object.getPrototypeOf(result) === Boolean.prototype"));
-    EXPECT_TRUE(EvaluateScriptForResultBool("result.valueOf() === true"));
-  });
-  RoundTripTest("new Boolean(false)", [this](Local<Value> value) {
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "Object.getPrototypeOf(result) === Boolean.prototype"));
-    EXPECT_TRUE(EvaluateScriptForResultBool("result.valueOf() === false"));
-  });
-  RoundTripTest(
-      "({ a: new Boolean(true), get b() { return this.a; }})",
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a instanceof Boolean"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === result.b"));
-      });
-  RoundTripTest("new Number(-42)", [this](Local<Value> value) {
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "Object.getPrototypeOf(result) === Number.prototype"));
-    EXPECT_TRUE(EvaluateScriptForResultBool("result.valueOf() === -42"));
-  });
-  RoundTripTest("new Number(NaN)", [this](Local<Value> value) {
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "Object.getPrototypeOf(result) === Number.prototype"));
-    EXPECT_TRUE(EvaluateScriptForResultBool("Number.isNaN(result.valueOf())"));
-  });
-  RoundTripTest(
-      "({ a: new Number(6), get b() { return this.a; }})",
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a instanceof Number"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === result.b"));
-      });
-  RoundTripTest("new String('Qu\\xe9bec')", [this](Local<Value> value) {
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "Object.getPrototypeOf(result) === String.prototype"));
-    EXPECT_TRUE(
-        EvaluateScriptForResultBool("result.valueOf() === 'Qu\\xe9bec'"));
-    EXPECT_TRUE(EvaluateScriptForResultBool("result.length === 6"));
-  });
-  RoundTripTest("new String('\\ud83d\\udc4a')", [this](Local<Value> value) {
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "Object.getPrototypeOf(result) === String.prototype"));
-    EXPECT_TRUE(
-        EvaluateScriptForResultBool("result.valueOf() === '\\ud83d\\udc4a'"));
-    EXPECT_TRUE(EvaluateScriptForResultBool("result.length === 2"));
-  });
-  RoundTripTest(
-      "({ a: new String(), get b() { return this.a; }})",
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a instanceof String"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === result.b"));
-      });
+  Local<Value> value = RoundTripTest("new Boolean(true)");
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Boolean.prototype");
+  ExpectScriptTrue("result.valueOf() === true");
+
+  value = RoundTripTest("new Boolean(false)");
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Boolean.prototype");
+  ExpectScriptTrue("result.valueOf() === false");
+
+  value =
+      RoundTripTest("({ a: new Boolean(true), get b() { return this.a; }})");
+  ExpectScriptTrue("result.a instanceof Boolean");
+  ExpectScriptTrue("result.a === result.b");
+
+  value = RoundTripTest("new Number(-42)");
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Number.prototype");
+  ExpectScriptTrue("result.valueOf() === -42");
+
+  value = RoundTripTest("new Number(NaN)");
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Number.prototype");
+  ExpectScriptTrue("Number.isNaN(result.valueOf())");
+
+  value = RoundTripTest("({ a: new Number(6), get b() { return this.a; }})");
+  ExpectScriptTrue("result.a instanceof Number");
+  ExpectScriptTrue("result.a === result.b");
+
+  value = RoundTripTest("new String('Qu\\xe9bec')");
+  ExpectScriptTrue("Object.getPrototypeOf(result) === String.prototype");
+  ExpectScriptTrue("result.valueOf() === 'Qu\\xe9bec'");
+  ExpectScriptTrue("result.length === 6");
+
+  value = RoundTripTest("new String('\\ud83d\\udc4a')");
+  ExpectScriptTrue("Object.getPrototypeOf(result) === String.prototype");
+  ExpectScriptTrue("result.valueOf() === '\\ud83d\\udc4a'");
+  ExpectScriptTrue("result.length === 2");
+
+  value = RoundTripTest("({ a: new String(), get b() { return this.a; }})");
+  ExpectScriptTrue("result.a instanceof String");
+  ExpectScriptTrue("result.a === result.b");
 }
 
 TEST_F(ValueSerializerTest, RejectsOtherValueObjects) {
@@ -1432,437 +1203,322 @@ TEST_F(ValueSerializerTest, RejectsOtherValueObjects) {
 }
 
 TEST_F(ValueSerializerTest, DecodeValueObjects) {
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x79, 0x00}, [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getPrototypeOf(result) === Boolean.prototype"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.valueOf() === true"));
-      });
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x78, 0x00}, [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getPrototypeOf(result) === Boolean.prototype"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.valueOf() === false"));
-      });
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x53, 0x01, 0x61, 0x3F, 0x01,
-       0x79, 0x3F, 0x02, 0x53, 0x01, 0x62, 0x3F, 0x02, 0x5E, 0x01, 0x7B, 0x02},
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a instanceof Boolean"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === result.b"));
-      });
+  Local<Value> value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x79, 0x00});
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Boolean.prototype");
+  ExpectScriptTrue("result.valueOf() === true");
+
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x78, 0x00});
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Boolean.prototype");
+  ExpectScriptTrue("result.valueOf() === false");
+
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x53,
+                      0x01, 0x61, 0x3F, 0x01, 0x79, 0x3F, 0x02, 0x53,
+                      0x01, 0x62, 0x3F, 0x02, 0x5E, 0x01, 0x7B, 0x02});
+  ExpectScriptTrue("result.a instanceof Boolean");
+  ExpectScriptTrue("result.a === result.b");
+
 #if defined(V8_TARGET_LITTLE_ENDIAN)
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45,
-       0xC0, 0x00},
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getPrototypeOf(result) === Number.prototype"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.valueOf() === -42"));
-      });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-              0xF8, 0x7F, 0x00},
-             [this](Local<Value> value) {
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === Number.prototype"));
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Number.isNaN(result.valueOf())"));
-             });
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x00,
+                      0x00, 0x00, 0x45, 0xC0, 0x00});
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Number.prototype");
+  ExpectScriptTrue("result.valueOf() === -42");
+
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x00,
+                      0x00, 0x00, 0xF8, 0x7F, 0x00});
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Number.prototype");
+  ExpectScriptTrue("Number.isNaN(result.valueOf())");
 #else
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x6E, 0xC0, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00,
-       0x00, 0x00},
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getPrototypeOf(result) === Number.prototype"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.valueOf() === -42"));
-      });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x6E, 0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00,
-              0x00, 0x00, 0x00},
-             [this](Local<Value> value) {
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === Number.prototype"));
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Number.isNaN(result.valueOf())"));
-             });
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x6E, 0xC0, 0x45, 0x00, 0x00,
+                      0x00, 0x00, 0x00, 0x00, 0x00});
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Number.prototype");
+  ExpectScriptTrue("result.valueOf() === -42");
+
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x6E, 0x7F, 0xF8, 0x00, 0x00,
+                      0x00, 0x00, 0x00, 0x00, 0x00});
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Number.prototype");
+  ExpectScriptTrue("Number.isNaN(result.valueOf())");
 #endif
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x53, 0x01, 0x61, 0x3F,
-       0x01, 0x6E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x40, 0x3F,
-       0x02, 0x53, 0x01, 0x62, 0x3F, 0x02, 0x5E, 0x01, 0x7B, 0x02},
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a instanceof Number"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === result.b"));
-      });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x73, 0x07, 0x51, 0x75, 0xC3, 0xA9, 0x62,
-              0x65, 0x63, 0x00},
-             [this](Local<Value> value) {
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === String.prototype"));
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "result.valueOf() === 'Qu\\xe9bec'"));
-               EXPECT_TRUE(EvaluateScriptForResultBool("result.length === 6"));
-             });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x73, 0x04, 0xF0, 0x9F, 0x91, 0x8A},
-             [this](Local<Value> value) {
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === String.prototype"));
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "result.valueOf() === '\\ud83d\\udc4a'"));
-               EXPECT_TRUE(EvaluateScriptForResultBool("result.length === 2"));
-             });
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x53, 0x01,
-       0x61, 0x3F, 0x01, 0x73, 0x00, 0x3F, 0x02, 0x53, 0x01,
-       0x62, 0x3F, 0x02, 0x5E, 0x01, 0x7B, 0x02, 0x00},
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a instanceof String"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === result.b"));
-      });
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x53,
+                      0x01, 0x61, 0x3F, 0x01, 0x6E, 0x00, 0x00, 0x00,
+                      0x00, 0x00, 0x00, 0x18, 0x40, 0x3F, 0x02, 0x53,
+                      0x01, 0x62, 0x3F, 0x02, 0x5E, 0x01, 0x7B, 0x02});
+  ExpectScriptTrue("result.a instanceof Number");
+  ExpectScriptTrue("result.a === result.b");
+
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x73, 0x07, 0x51, 0x75, 0xC3,
+                      0xA9, 0x62, 0x65, 0x63, 0x00});
+  ExpectScriptTrue("Object.getPrototypeOf(result) === String.prototype");
+  ExpectScriptTrue("result.valueOf() === 'Qu\\xe9bec'");
+  ExpectScriptTrue("result.length === 6");
+
+  value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x73, 0x04, 0xF0, 0x9F, 0x91, 0x8A});
+  ExpectScriptTrue("Object.getPrototypeOf(result) === String.prototype");
+  ExpectScriptTrue("result.valueOf() === '\\ud83d\\udc4a'");
+  ExpectScriptTrue("result.length === 2");
+
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x53, 0x01,
+                      0x61, 0x3F, 0x01, 0x73, 0x00, 0x3F, 0x02, 0x53, 0x01,
+                      0x62, 0x3F, 0x02, 0x5E, 0x01, 0x7B, 0x02, 0x00});
+  ExpectScriptTrue("result.a instanceof String");
+  ExpectScriptTrue("result.a === result.b");
 
   // String object containing a Latin-1 string.
-  DecodeTest({0xFF, 0x0C, 0x73, 0x22, 0x06, 'Q', 'u', 0xE9, 'b', 'e', 'c'},
-             [this](Local<Value> value) {
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === String.prototype"));
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "result.valueOf() === 'Qu\\xe9bec'"));
-               EXPECT_TRUE(EvaluateScriptForResultBool("result.length === 6"));
-             });
+  value =
+      DecodeTest({0xFF, 0x0C, 0x73, 0x22, 0x06, 'Q', 'u', 0xE9, 'b', 'e', 'c'});
+  ExpectScriptTrue("Object.getPrototypeOf(result) === String.prototype");
+  ExpectScriptTrue("result.valueOf() === 'Qu\\xe9bec'");
+  ExpectScriptTrue("result.length === 6");
 }
 
 TEST_F(ValueSerializerTest, RoundTripRegExp) {
-  RoundTripTest("/foo/g", [this](Local<Value> value) {
-    ASSERT_TRUE(value->IsRegExp());
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "Object.getPrototypeOf(result) === RegExp.prototype"));
-    EXPECT_TRUE(EvaluateScriptForResultBool("result.toString() === '/foo/g'"));
-  });
-  RoundTripTest("new RegExp('Qu\\xe9bec', 'i')", [this](Local<Value> value) {
-    ASSERT_TRUE(value->IsRegExp());
-    EXPECT_TRUE(
-        EvaluateScriptForResultBool("result.toString() === '/Qu\\xe9bec/i'"));
-  });
-  RoundTripTest("new RegExp('\\ud83d\\udc4a', 'ug')",
-                [this](Local<Value> value) {
-                  ASSERT_TRUE(value->IsRegExp());
-                  EXPECT_TRUE(EvaluateScriptForResultBool(
-                      "result.toString() === '/\\ud83d\\udc4a/gu'"));
-                });
-  RoundTripTest(
-      "({ a: /foo/gi, get b() { return this.a; }})",
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a instanceof RegExp"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === result.b"));
-      });
+  Local<Value> value = RoundTripTest("/foo/g");
+  ASSERT_TRUE(value->IsRegExp());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === RegExp.prototype");
+  ExpectScriptTrue("result.toString() === '/foo/g'");
+
+  value = RoundTripTest("new RegExp('Qu\\xe9bec', 'i')");
+  ASSERT_TRUE(value->IsRegExp());
+  ExpectScriptTrue("result.toString() === '/Qu\\xe9bec/i'");
+
+  value = RoundTripTest("new RegExp('\\ud83d\\udc4a', 'ug')");
+  ASSERT_TRUE(value->IsRegExp());
+  ExpectScriptTrue("result.toString() === '/\\ud83d\\udc4a/gu'");
+
+  value = RoundTripTest("({ a: /foo/gi, get b() { return this.a; }})");
+  ExpectScriptTrue("result.a instanceof RegExp");
+  ExpectScriptTrue("result.a === result.b");
 }
 
 TEST_F(ValueSerializerTest, DecodeRegExp) {
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x52, 0x03, 0x66, 0x6F, 0x6F, 0x01},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsRegExp());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === RegExp.prototype"));
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "result.toString() === '/foo/g'"));
-             });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x52, 0x07, 0x51, 0x75, 0xC3, 0xA9, 0x62,
-              0x65, 0x63, 0x02},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsRegExp());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "result.toString() === '/Qu\\xe9bec/i'"));
-             });
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x52, 0x04, 0xF0, 0x9F, 0x91, 0x8A, 0x11, 0x00},
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsRegExp());
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "result.toString() === '/\\ud83d\\udc4a/gu'"));
-      });
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x53, 0x01, 0x61,
-       0x3F, 0x01, 0x52, 0x03, 0x66, 0x6F, 0x6F, 0x03, 0x3F, 0x02,
-       0x53, 0x01, 0x62, 0x3F, 0x02, 0x5E, 0x01, 0x7B, 0x02, 0x00},
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a instanceof RegExp"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === result.b"));
-      });
+  Local<Value> value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x52, 0x03, 0x66, 0x6F, 0x6F, 0x01});
+  ASSERT_TRUE(value->IsRegExp());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === RegExp.prototype");
+  ExpectScriptTrue("result.toString() === '/foo/g'");
+
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x52, 0x07, 0x51, 0x75, 0xC3,
+                      0xA9, 0x62, 0x65, 0x63, 0x02});
+  ASSERT_TRUE(value->IsRegExp());
+  ExpectScriptTrue("result.toString() === '/Qu\\xe9bec/i'");
+
+  value = DecodeTest(
+      {0xFF, 0x09, 0x3F, 0x00, 0x52, 0x04, 0xF0, 0x9F, 0x91, 0x8A, 0x11, 0x00});
+  ASSERT_TRUE(value->IsRegExp());
+  ExpectScriptTrue("result.toString() === '/\\ud83d\\udc4a/gu'");
+
+  value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x53, 0x01, 0x61,
+                  0x3F, 0x01, 0x52, 0x03, 0x66, 0x6F, 0x6F, 0x03, 0x3F, 0x02,
+                  0x53, 0x01, 0x62, 0x3F, 0x02, 0x5E, 0x01, 0x7B, 0x02, 0x00});
+  ExpectScriptTrue("result.a instanceof RegExp");
+  ExpectScriptTrue("result.a === result.b");
 
   // RegExp containing a Latin-1 string.
-  DecodeTest(
-      {0xFF, 0x0C, 0x52, 0x22, 0x06, 'Q', 'u', 0xE9, 'b', 'e', 'c', 0x02},
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsRegExp());
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "result.toString() === '/Qu\\xe9bec/i'"));
-      });
+  value = DecodeTest(
+      {0xFF, 0x0C, 0x52, 0x22, 0x06, 'Q', 'u', 0xE9, 'b', 'e', 'c', 0x02});
+  ASSERT_TRUE(value->IsRegExp());
+  ExpectScriptTrue("result.toString() === '/Qu\\xe9bec/i'");
 }
 
 // Tests that invalid flags are not accepted by the deserializer.
 TEST_F(ValueSerializerTest, DecodeRegExpDotAll) {
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x52, 0x03, 0x66, 0x6F, 0x6F, 0x1F},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsRegExp());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === RegExp.prototype"));
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "result.toString() === '/foo/gimuy'"));
-             });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x52, 0x03, 0x66, 0x6F, 0x6F, 0x3F},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsRegExp());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === RegExp.prototype"));
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "result.toString() === '/foo/gimsuy'"));
-             });
+  Local<Value> value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x52, 0x03, 0x66, 0x6F, 0x6F, 0x1F});
+  ASSERT_TRUE(value->IsRegExp());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === RegExp.prototype");
+  ExpectScriptTrue("result.toString() === '/foo/gimuy'");
+
+  value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x52, 0x03, 0x66, 0x6F, 0x6F, 0x3F});
+  ASSERT_TRUE(value->IsRegExp());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === RegExp.prototype");
+  ExpectScriptTrue("result.toString() === '/foo/gimsuy'");
+
   InvalidDecodeTest(
       {0xFF, 0x09, 0x3F, 0x00, 0x52, 0x03, 0x66, 0x6F, 0x6F, 0x7F});
 }
 
 TEST_F(ValueSerializerTest, RoundTripMap) {
-  RoundTripTest(
-      "(() => { var m = new Map(); m.set(42, 'foo'); return m; })()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsMap());
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getPrototypeOf(result) === Map.prototype"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.size === 1"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.get(42) === 'foo'"));
-      });
-  RoundTripTest("(() => { var m = new Map(); m.set(m, m); return m; })()",
-                [this](Local<Value> value) {
-                  ASSERT_TRUE(value->IsMap());
-                  EXPECT_TRUE(EvaluateScriptForResultBool("result.size === 1"));
-                  EXPECT_TRUE(EvaluateScriptForResultBool(
-                      "result.get(result) === result"));
-                });
+  Local<Value> value = RoundTripTest("var m = new Map(); m.set(42, 'foo'); m;");
+  ASSERT_TRUE(value->IsMap());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Map.prototype");
+  ExpectScriptTrue("result.size === 1");
+  ExpectScriptTrue("result.get(42) === 'foo'");
+
+  value = RoundTripTest("var m = new Map(); m.set(m, m); m;");
+  ASSERT_TRUE(value->IsMap());
+  ExpectScriptTrue("result.size === 1");
+  ExpectScriptTrue("result.get(result) === result");
+
   // Iteration order must be preserved.
-  RoundTripTest(
-      "(() => {"
-      "  var m = new Map();"
-      "  m.set(1, 0); m.set('a', 0); m.set(3, 0); m.set(2, 0);"
-      "  return m;"
-      "})()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsMap());
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Array.from(result.keys()).toString() === '1,a,3,2'"));
-      });
+  value = RoundTripTest(
+      "var m = new Map();"
+      "m.set(1, 0); m.set('a', 0); m.set(3, 0); m.set(2, 0);"
+      "m;");
+  ASSERT_TRUE(value->IsMap());
+  ExpectScriptTrue("Array.from(result.keys()).toString() === '1,a,3,2'");
 }
 
 TEST_F(ValueSerializerTest, DecodeMap) {
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x3B, 0x3F, 0x01, 0x49, 0x54, 0x3F, 0x01, 0x53,
-       0x03, 0x66, 0x6F, 0x6F, 0x3A, 0x02},
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsMap());
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getPrototypeOf(result) === Map.prototype"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.size === 1"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.get(42) === 'foo'"));
-      });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3B, 0x3F, 0x01, 0x5E, 0x00, 0x3F, 0x01,
-              0x5E, 0x00, 0x3A, 0x02, 0x00},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsMap());
-               EXPECT_TRUE(EvaluateScriptForResultBool("result.size === 1"));
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "result.get(result) === result"));
-             });
+  Local<Value> value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3B, 0x3F, 0x01, 0x49, 0x54, 0x3F,
+                  0x01, 0x53, 0x03, 0x66, 0x6F, 0x6F, 0x3A, 0x02});
+  ASSERT_TRUE(value->IsMap());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Map.prototype");
+  ExpectScriptTrue("result.size === 1");
+  ExpectScriptTrue("result.get(42) === 'foo'");
+
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3B, 0x3F, 0x01, 0x5E, 0x00,
+                      0x3F, 0x01, 0x5E, 0x00, 0x3A, 0x02, 0x00});
+  ASSERT_TRUE(value->IsMap());
+  ExpectScriptTrue("result.size === 1");
+  ExpectScriptTrue("result.get(result) === result");
+
   // Iteration order must be preserved.
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3B, 0x3F, 0x01, 0x49, 0x02, 0x3F,
-              0x01, 0x49, 0x00, 0x3F, 0x01, 0x53, 0x01, 0x61, 0x3F, 0x01,
-              0x49, 0x00, 0x3F, 0x01, 0x49, 0x06, 0x3F, 0x01, 0x49, 0x00,
-              0x3F, 0x01, 0x49, 0x04, 0x3F, 0x01, 0x49, 0x00, 0x3A, 0x08},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsMap());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Array.from(result.keys()).toString() === '1,a,3,2'"));
-             });
+  value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3B, 0x3F, 0x01, 0x49, 0x02, 0x3F,
+                  0x01, 0x49, 0x00, 0x3F, 0x01, 0x53, 0x01, 0x61, 0x3F, 0x01,
+                  0x49, 0x00, 0x3F, 0x01, 0x49, 0x06, 0x3F, 0x01, 0x49, 0x00,
+                  0x3F, 0x01, 0x49, 0x04, 0x3F, 0x01, 0x49, 0x00, 0x3A, 0x08});
+  ASSERT_TRUE(value->IsMap());
+  ExpectScriptTrue("Array.from(result.keys()).toString() === '1,a,3,2'");
 }
 
 TEST_F(ValueSerializerTest, RoundTripMapWithTrickyGetters) {
   // Even if an entry is removed or reassigned, the original key/value pair is
   // used.
-  RoundTripTest(
-      "(() => {"
-      "  var m = new Map();"
-      "  m.set(0, { get a() {"
-      "    m.delete(1); m.set(2, 'baz'); m.set(3, 'quux');"
-      "  }});"
-      "  m.set(1, 'foo');"
-      "  m.set(2, 'bar');"
-      "  return m;"
-      "})()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsMap());
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Array.from(result.keys()).toString() === '0,1,2'"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.get(1) === 'foo'"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.get(2) === 'bar'"));
-      });
+  Local<Value> value = RoundTripTest(
+      "var m = new Map();"
+      "m.set(0, { get a() {"
+      "  m.delete(1); m.set(2, 'baz'); m.set(3, 'quux');"
+      "}});"
+      "m.set(1, 'foo');"
+      "m.set(2, 'bar');"
+      "m;");
+  ASSERT_TRUE(value->IsMap());
+  ExpectScriptTrue("Array.from(result.keys()).toString() === '0,1,2'");
+  ExpectScriptTrue("result.get(1) === 'foo'");
+  ExpectScriptTrue("result.get(2) === 'bar'");
+
   // However, deeper modifications of objects yet to be serialized still apply.
-  RoundTripTest(
-      "(() => {"
-      "  var m = new Map();"
-      "  var key = { get a() { value.foo = 'bar'; } };"
-      "  var value = { get a() { key.baz = 'quux'; } };"
-      "  m.set(key, value);"
-      "  return m;"
-      "})()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsMap());
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "!('baz' in Array.from(result.keys())[0])"));
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Array.from(result.values())[0].foo === 'bar'"));
-      });
+  value = RoundTripTest(
+      "var m = new Map();"
+      "var key = { get a() { value.foo = 'bar'; } };"
+      "var value = { get a() { key.baz = 'quux'; } };"
+      "m.set(key, value);"
+      "m;");
+  ASSERT_TRUE(value->IsMap());
+  ExpectScriptTrue("!('baz' in Array.from(result.keys())[0])");
+  ExpectScriptTrue("Array.from(result.values())[0].foo === 'bar'");
 }
 
 TEST_F(ValueSerializerTest, RoundTripSet) {
-  RoundTripTest(
-      "(() => { var s = new Set(); s.add(42); s.add('foo'); return s; })()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsSet());
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getPrototypeOf(result) === Set.prototype"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.size === 2"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.has(42)"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.has('foo')"));
-      });
-  RoundTripTest(
-      "(() => { var s = new Set(); s.add(s); return s; })()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsSet());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.size === 1"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.has(result)"));
-      });
+  Local<Value> value =
+      RoundTripTest("var s = new Set(); s.add(42); s.add('foo'); s;");
+  ASSERT_TRUE(value->IsSet());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Set.prototype");
+  ExpectScriptTrue("result.size === 2");
+  ExpectScriptTrue("result.has(42)");
+  ExpectScriptTrue("result.has('foo')");
+
+  value = RoundTripTest("var s = new Set(); s.add(s); s;");
+  ASSERT_TRUE(value->IsSet());
+  ExpectScriptTrue("result.size === 1");
+  ExpectScriptTrue("result.has(result)");
+
   // Iteration order must be preserved.
-  RoundTripTest(
-      "(() => {"
-      "  var s = new Set();"
-      "  s.add(1); s.add('a'); s.add(3); s.add(2);"
-      "  return s;"
-      "})()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsSet());
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Array.from(result.keys()).toString() === '1,a,3,2'"));
-      });
+  value = RoundTripTest(
+      "var s = new Set();"
+      "s.add(1); s.add('a'); s.add(3); s.add(2);"
+      "s;");
+  ASSERT_TRUE(value->IsSet());
+  ExpectScriptTrue("Array.from(result.keys()).toString() === '1,a,3,2'");
 }
 
 TEST_F(ValueSerializerTest, DecodeSet) {
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x27, 0x3F, 0x01, 0x49, 0x54, 0x3F, 0x01,
-              0x53, 0x03, 0x66, 0x6F, 0x6F, 0x2C, 0x02},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsSet());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === Set.prototype"));
-               EXPECT_TRUE(EvaluateScriptForResultBool("result.size === 2"));
-               EXPECT_TRUE(EvaluateScriptForResultBool("result.has(42)"));
-               EXPECT_TRUE(EvaluateScriptForResultBool("result.has('foo')"));
-             });
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x27, 0x3F, 0x01, 0x5E, 0x00, 0x2C, 0x01, 0x00},
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsSet());
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.size === 1"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.has(result)"));
-      });
+  Local<Value> value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x27, 0x3F, 0x01, 0x49, 0x54, 0x3F,
+                  0x01, 0x53, 0x03, 0x66, 0x6F, 0x6F, 0x2C, 0x02});
+  ASSERT_TRUE(value->IsSet());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Set.prototype");
+  ExpectScriptTrue("result.size === 2");
+  ExpectScriptTrue("result.has(42)");
+  ExpectScriptTrue("result.has('foo')");
+
+  value = DecodeTest(
+      {0xFF, 0x09, 0x3F, 0x00, 0x27, 0x3F, 0x01, 0x5E, 0x00, 0x2C, 0x01, 0x00});
+  ASSERT_TRUE(value->IsSet());
+  ExpectScriptTrue("result.size === 1");
+  ExpectScriptTrue("result.has(result)");
+
   // Iteration order must be preserved.
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x27, 0x3F, 0x01, 0x49, 0x02, 0x3F, 0x01, 0x53,
-       0x01, 0x61, 0x3F, 0x01, 0x49, 0x06, 0x3F, 0x01, 0x49, 0x04, 0x2C, 0x04},
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsSet());
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Array.from(result.keys()).toString() === '1,a,3,2'"));
-      });
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x27, 0x3F, 0x01, 0x49,
+                      0x02, 0x3F, 0x01, 0x53, 0x01, 0x61, 0x3F, 0x01,
+                      0x49, 0x06, 0x3F, 0x01, 0x49, 0x04, 0x2C, 0x04});
+  ASSERT_TRUE(value->IsSet());
+  ExpectScriptTrue("Array.from(result.keys()).toString() === '1,a,3,2'");
 }
 
 TEST_F(ValueSerializerTest, RoundTripSetWithTrickyGetters) {
   // Even if an element is added or removed during serialization, the original
   // set of elements is used.
-  RoundTripTest(
-      "(() => {"
-      "  var s = new Set();"
-      "  s.add({ get a() { s.delete(1); s.add(2); } });"
-      "  s.add(1);"
-      "  return s;"
-      "})()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsSet());
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Array.from(result.keys()).toString() === '[object Object],1'"));
-      });
+  Local<Value> value = RoundTripTest(
+      "var s = new Set();"
+      "s.add({ get a() { s.delete(1); s.add(2); } });"
+      "s.add(1);"
+      "s;");
+  ASSERT_TRUE(value->IsSet());
+  ExpectScriptTrue(
+      "Array.from(result.keys()).toString() === '[object Object],1'");
+
   // However, deeper modifications of objects yet to be serialized still apply.
-  RoundTripTest(
-      "(() => {"
-      "  var s = new Set();"
-      "  var first = { get a() { second.foo = 'bar'; } };"
-      "  var second = { get a() { first.baz = 'quux'; } };"
-      "  s.add(first);"
-      "  s.add(second);"
-      "  return s;"
-      "})()",
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsSet());
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "!('baz' in Array.from(result.keys())[0])"));
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Array.from(result.keys())[1].foo === 'bar'"));
-      });
+  value = RoundTripTest(
+      "var s = new Set();"
+      "var first = { get a() { second.foo = 'bar'; } };"
+      "var second = { get a() { first.baz = 'quux'; } };"
+      "s.add(first);"
+      "s.add(second);"
+      "s;");
+  ASSERT_TRUE(value->IsSet());
+  ExpectScriptTrue("!('baz' in Array.from(result.keys())[0])");
+  ExpectScriptTrue("Array.from(result.keys())[1].foo === 'bar'");
 }
 
 TEST_F(ValueSerializerTest, RoundTripArrayBuffer) {
-  RoundTripTest("new ArrayBuffer()", [this](Local<Value> value) {
-    ASSERT_TRUE(value->IsArrayBuffer());
-    EXPECT_EQ(0u, ArrayBuffer::Cast(*value)->ByteLength());
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "Object.getPrototypeOf(result) === ArrayBuffer.prototype"));
-  });
-  RoundTripTest("new Uint8Array([0, 128, 255]).buffer",
-                [this](Local<Value> value) {
-                  ASSERT_TRUE(value->IsArrayBuffer());
-                  EXPECT_EQ(3u, ArrayBuffer::Cast(*value)->ByteLength());
-                  EXPECT_TRUE(EvaluateScriptForResultBool(
-                      "new Uint8Array(result).toString() === '0,128,255'"));
-                });
-  RoundTripTest(
-      "({ a: new ArrayBuffer(), get b() { return this.a; }})",
-      [this](Local<Value> value) {
-        EXPECT_TRUE(
-            EvaluateScriptForResultBool("result.a instanceof ArrayBuffer"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === result.b"));
-      });
+  Local<Value> value = RoundTripTest("new ArrayBuffer()");
+  ASSERT_TRUE(value->IsArrayBuffer());
+  EXPECT_EQ(0u, ArrayBuffer::Cast(*value)->ByteLength());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === ArrayBuffer.prototype");
+
+  value = RoundTripTest("new Uint8Array([0, 128, 255]).buffer");
+  ASSERT_TRUE(value->IsArrayBuffer());
+  EXPECT_EQ(3u, ArrayBuffer::Cast(*value)->ByteLength());
+  ExpectScriptTrue("new Uint8Array(result).toString() === '0,128,255'");
+
+  value =
+      RoundTripTest("({ a: new ArrayBuffer(), get b() { return this.a; }})");
+  ExpectScriptTrue("result.a instanceof ArrayBuffer");
+  ExpectScriptTrue("result.a === result.b");
 }
 
 TEST_F(ValueSerializerTest, DecodeArrayBuffer) {
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x42, 0x00},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsArrayBuffer());
-               EXPECT_EQ(0u, ArrayBuffer::Cast(*value)->ByteLength());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === ArrayBuffer.prototype"));
-             });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x42, 0x03, 0x00, 0x80, 0xFF, 0x00},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsArrayBuffer());
-               EXPECT_EQ(3u, ArrayBuffer::Cast(*value)->ByteLength());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "new Uint8Array(result).toString() === '0,128,255'"));
-             });
-  DecodeTest(
-      {0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x53, 0x01,
-       0x61, 0x3F, 0x01, 0x42, 0x00, 0x3F, 0x02, 0x53, 0x01,
-       0x62, 0x3F, 0x02, 0x5E, 0x01, 0x7B, 0x02, 0x00},
-      [this](Local<Value> value) {
-        EXPECT_TRUE(
-            EvaluateScriptForResultBool("result.a instanceof ArrayBuffer"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === result.b"));
-      });
+  Local<Value> value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x42, 0x00});
+  ASSERT_TRUE(value->IsArrayBuffer());
+  EXPECT_EQ(0u, ArrayBuffer::Cast(*value)->ByteLength());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === ArrayBuffer.prototype");
+
+  value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x42, 0x03, 0x00, 0x80, 0xFF, 0x00});
+  ASSERT_TRUE(value->IsArrayBuffer());
+  EXPECT_EQ(3u, ArrayBuffer::Cast(*value)->ByteLength());
+  ExpectScriptTrue("new Uint8Array(result).toString() === '0,128,255'");
+
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x53, 0x01,
+                      0x61, 0x3F, 0x01, 0x42, 0x00, 0x3F, 0x02, 0x53, 0x01,
+                      0x62, 0x3F, 0x02, 0x5E, 0x01, 0x7B, 0x02, 0x00});
+  ExpectScriptTrue("result.a instanceof ArrayBuffer");
+  ExpectScriptTrue("result.a === result.b");
 }
 
 TEST_F(ValueSerializerTest, DecodeInvalidArrayBuffer) {
@@ -1943,196 +1599,161 @@ class ValueSerializerTestWithArrayBufferTransfer : public ValueSerializerTest {
 
 TEST_F(ValueSerializerTestWithArrayBufferTransfer,
        RoundTripArrayBufferTransfer) {
-  RoundTripTest([this]() { return input_buffer(); },
-                [this](Local<Value> value) {
-                  ASSERT_TRUE(value->IsArrayBuffer());
-                  EXPECT_EQ(output_buffer(), value);
-                  EXPECT_TRUE(EvaluateScriptForResultBool(
-                      "new Uint8Array(result).toString() === '0,1,128,255'"));
-                });
-  RoundTripTest(
-      [this]() {
-        Local<Object> object = Object::New(isolate());
-        EXPECT_TRUE(object
-                        ->CreateDataProperty(serialization_context(),
-                                             StringFromUtf8("a"),
-                                             input_buffer())
-                        .FromMaybe(false));
-        EXPECT_TRUE(object
-                        ->CreateDataProperty(serialization_context(),
-                                             StringFromUtf8("b"),
-                                             input_buffer())
-                        .FromMaybe(false));
-        return object;
-      },
-      [this](Local<Value> value) {
-        EXPECT_TRUE(
-            EvaluateScriptForResultBool("result.a instanceof ArrayBuffer"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === result.b"));
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "new Uint8Array(result.a).toString() === '0,1,128,255'"));
-      });
+  Local<Value> value = RoundTripTest(input_buffer());
+  ASSERT_TRUE(value->IsArrayBuffer());
+  EXPECT_EQ(output_buffer(), value);
+  ExpectScriptTrue("new Uint8Array(result).toString() === '0,1,128,255'");
+
+  Local<Object> object;
+  {
+    Context::Scope scope(serialization_context());
+    object = Object::New(isolate());
+    EXPECT_TRUE(object
+                    ->CreateDataProperty(serialization_context(),
+                                         StringFromUtf8("a"), input_buffer())
+                    .FromMaybe(false));
+    EXPECT_TRUE(object
+                    ->CreateDataProperty(serialization_context(),
+                                         StringFromUtf8("b"), input_buffer())
+                    .FromMaybe(false));
+  }
+  value = RoundTripTest(object);
+  ExpectScriptTrue("result.a instanceof ArrayBuffer");
+  ExpectScriptTrue("result.a === result.b");
+  ExpectScriptTrue("new Uint8Array(result.a).toString() === '0,1,128,255'");
 }
 
 TEST_F(ValueSerializerTest, RoundTripTypedArray) {
-// Check that the right type comes out the other side for every kind of typed
-// array.
-#define TYPED_ARRAY_ROUND_TRIP_TEST(Type, type, TYPE, ctype, size)      \
-  RoundTripTest("new " #Type "Array(2)", [this](Local<Value> value) {   \
-    ASSERT_TRUE(value->Is##Type##Array());                              \
-    EXPECT_EQ(2u * size, TypedArray::Cast(*value)->ByteLength());       \
-    EXPECT_EQ(2u, TypedArray::Cast(*value)->Length());                  \
-    EXPECT_TRUE(EvaluateScriptForResultBool(                            \
-        "Object.getPrototypeOf(result) === " #Type "Array.prototype")); \
-  });
+  // Check that the right type comes out the other side for every kind of typed
+  // array.
+  Local<Value> value;
+#define TYPED_ARRAY_ROUND_TRIP_TEST(Type, type, TYPE, ctype, size) \
+  value = RoundTripTest("new " #Type "Array(2)");                  \
+  ASSERT_TRUE(value->Is##Type##Array());                           \
+  EXPECT_EQ(2u * size, TypedArray::Cast(*value)->ByteLength());    \
+  EXPECT_EQ(2u, TypedArray::Cast(*value)->Length());               \
+  ExpectScriptTrue("Object.getPrototypeOf(result) === " #Type      \
+                   "Array.prototype");
+
   TYPED_ARRAYS(TYPED_ARRAY_ROUND_TRIP_TEST)
-#undef TYPED_ARRAY_CASE
+#undef TYPED_ARRAY_ROUND_TRIP_TEST
 
   // Check that values of various kinds are suitably preserved.
-  RoundTripTest("new Uint8Array([1, 128, 255])", [this](Local<Value> value) {
-    EXPECT_TRUE(
-        EvaluateScriptForResultBool("result.toString() === '1,128,255'"));
-  });
-  RoundTripTest("new Int16Array([0, 256, -32768])", [this](Local<Value> value) {
-    EXPECT_TRUE(
-        EvaluateScriptForResultBool("result.toString() === '0,256,-32768'"));
-  });
-  RoundTripTest("new Float32Array([0, -0.5, NaN, Infinity])",
-                [this](Local<Value> value) {
-                  EXPECT_TRUE(EvaluateScriptForResultBool(
-                      "result.toString() === '0,-0.5,NaN,Infinity'"));
-                });
+  value = RoundTripTest("new Uint8Array([1, 128, 255])");
+  ExpectScriptTrue("result.toString() === '1,128,255'");
+
+  value = RoundTripTest("new Int16Array([0, 256, -32768])");
+  ExpectScriptTrue("result.toString() === '0,256,-32768'");
+
+  value = RoundTripTest("new Float32Array([0, -0.5, NaN, Infinity])");
+  ExpectScriptTrue("result.toString() === '0,-0.5,NaN,Infinity'");
 
   // Array buffer views sharing a buffer should do so on the other side.
   // Similarly, multiple references to the same typed array should be resolved.
-  RoundTripTest(
-      "(() => {"
-      "  var buffer = new ArrayBuffer(32);"
-      "  return {"
-      "    u8: new Uint8Array(buffer),"
-      "    get u8_2() { return this.u8; },"
-      "    f32: new Float32Array(buffer, 4, 5),"
-      "    b: buffer,"
-      "  };"
-      "})()",
-      [this](Local<Value> value) {
-        EXPECT_TRUE(
-            EvaluateScriptForResultBool("result.u8 instanceof Uint8Array"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.u8 === result.u8_2"));
-        EXPECT_TRUE(
-            EvaluateScriptForResultBool("result.f32 instanceof Float32Array"));
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "result.u8.buffer === result.f32.buffer"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.f32.byteOffset === 4"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.f32.length === 5"));
-      });
+  value = RoundTripTest(
+      "var buffer = new ArrayBuffer(32);"
+      "({"
+      "  u8: new Uint8Array(buffer),"
+      "  get u8_2() { return this.u8; },"
+      "  f32: new Float32Array(buffer, 4, 5),"
+      "  b: buffer,"
+      "});");
+  ExpectScriptTrue("result.u8 instanceof Uint8Array");
+  ExpectScriptTrue("result.u8 === result.u8_2");
+  ExpectScriptTrue("result.f32 instanceof Float32Array");
+  ExpectScriptTrue("result.u8.buffer === result.f32.buffer");
+  ExpectScriptTrue("result.f32.byteOffset === 4");
+  ExpectScriptTrue("result.f32.length === 5");
 }
 
 TEST_F(ValueSerializerTest, DecodeTypedArray) {
   // Check that the right type comes out the other side for every kind of typed
   // array.
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x02, 0x00, 0x00, 0x56,
-              0x42, 0x00, 0x02},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsUint8Array());
-               EXPECT_EQ(2u, TypedArray::Cast(*value)->ByteLength());
-               EXPECT_EQ(2u, TypedArray::Cast(*value)->Length());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === Uint8Array.prototype"));
-             });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x02, 0x00, 0x00, 0x56,
-              0x62, 0x00, 0x02},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsInt8Array());
-               EXPECT_EQ(2u, TypedArray::Cast(*value)->ByteLength());
-               EXPECT_EQ(2u, TypedArray::Cast(*value)->Length());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === Int8Array.prototype"));
-             });
+  Local<Value> value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42,
+                                   0x02, 0x00, 0x00, 0x56, 0x42, 0x00, 0x02});
+  ASSERT_TRUE(value->IsUint8Array());
+  EXPECT_EQ(2u, TypedArray::Cast(*value)->ByteLength());
+  EXPECT_EQ(2u, TypedArray::Cast(*value)->Length());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Uint8Array.prototype");
+
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x02, 0x00,
+                      0x00, 0x56, 0x62, 0x00, 0x02});
+  ASSERT_TRUE(value->IsInt8Array());
+  EXPECT_EQ(2u, TypedArray::Cast(*value)->ByteLength());
+  EXPECT_EQ(2u, TypedArray::Cast(*value)->Length());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Int8Array.prototype");
+
 #if defined(V8_TARGET_LITTLE_ENDIAN)
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x04, 0x00, 0x00, 0x00,
-              0x00, 0x56, 0x57, 0x00, 0x04},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsUint16Array());
-               EXPECT_EQ(4u, TypedArray::Cast(*value)->ByteLength());
-               EXPECT_EQ(2u, TypedArray::Cast(*value)->Length());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === Uint16Array.prototype"));
-             });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x04, 0x00, 0x00, 0x00,
-              0x00, 0x56, 0x77, 0x00, 0x04},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsInt16Array());
-               EXPECT_EQ(4u, TypedArray::Cast(*value)->ByteLength());
-               EXPECT_EQ(2u, TypedArray::Cast(*value)->Length());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === Int16Array.prototype"));
-             });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x08, 0x00, 0x00,
-              0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x44, 0x00, 0x08},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsUint32Array());
-               EXPECT_EQ(8u, TypedArray::Cast(*value)->ByteLength());
-               EXPECT_EQ(2u, TypedArray::Cast(*value)->Length());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === Uint32Array.prototype"));
-             });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x08, 0x00, 0x00,
-              0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x64, 0x00, 0x08},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsInt32Array());
-               EXPECT_EQ(8u, TypedArray::Cast(*value)->ByteLength());
-               EXPECT_EQ(2u, TypedArray::Cast(*value)->Length());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === Int32Array.prototype"));
-             });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x08, 0x00, 0x00,
-              0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x66, 0x00, 0x08},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsFloat32Array());
-               EXPECT_EQ(8u, TypedArray::Cast(*value)->ByteLength());
-               EXPECT_EQ(2u, TypedArray::Cast(*value)->Length());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === Float32Array.prototype"));
-             });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x10, 0x00, 0x00,
-              0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-              0x00, 0x00, 0x00, 0x00, 0x56, 0x46, 0x00, 0x10},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsFloat64Array());
-               EXPECT_EQ(16u, TypedArray::Cast(*value)->ByteLength());
-               EXPECT_EQ(2u, TypedArray::Cast(*value)->Length());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === Float64Array.prototype"));
-             });
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x04, 0x00,
+                      0x00, 0x00, 0x00, 0x56, 0x57, 0x00, 0x04});
+  ASSERT_TRUE(value->IsUint16Array());
+  EXPECT_EQ(4u, TypedArray::Cast(*value)->ByteLength());
+  EXPECT_EQ(2u, TypedArray::Cast(*value)->Length());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Uint16Array.prototype");
+
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x04, 0x00,
+                      0x00, 0x00, 0x00, 0x56, 0x77, 0x00, 0x04});
+  ASSERT_TRUE(value->IsInt16Array());
+  EXPECT_EQ(4u, TypedArray::Cast(*value)->ByteLength());
+  EXPECT_EQ(2u, TypedArray::Cast(*value)->Length());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Int16Array.prototype");
+
+  value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x08, 0x00, 0x00,
+                  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x44, 0x00, 0x08});
+  ASSERT_TRUE(value->IsUint32Array());
+  EXPECT_EQ(8u, TypedArray::Cast(*value)->ByteLength());
+  EXPECT_EQ(2u, TypedArray::Cast(*value)->Length());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Uint32Array.prototype");
+
+  value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x08, 0x00, 0x00,
+                  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x64, 0x00, 0x08});
+  ASSERT_TRUE(value->IsInt32Array());
+  EXPECT_EQ(8u, TypedArray::Cast(*value)->ByteLength());
+  EXPECT_EQ(2u, TypedArray::Cast(*value)->Length());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Int32Array.prototype");
+
+  value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x08, 0x00, 0x00,
+                  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0x66, 0x00, 0x08});
+  ASSERT_TRUE(value->IsFloat32Array());
+  EXPECT_EQ(8u, TypedArray::Cast(*value)->ByteLength());
+  EXPECT_EQ(2u, TypedArray::Cast(*value)->Length());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Float32Array.prototype");
+
+  value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x10, 0x00, 0x00,
+                  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                  0x00, 0x00, 0x00, 0x00, 0x56, 0x46, 0x00, 0x10});
+  ASSERT_TRUE(value->IsFloat64Array());
+  EXPECT_EQ(16u, TypedArray::Cast(*value)->ByteLength());
+  EXPECT_EQ(2u, TypedArray::Cast(*value)->Length());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === Float64Array.prototype");
+
 #endif  // V8_TARGET_LITTLE_ENDIAN
 
   // Check that values of various kinds are suitably preserved.
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x03, 0x01, 0x80, 0xFF,
-              0x56, 0x42, 0x00, 0x03, 0x00},
-             [this](Local<Value> value) {
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "result.toString() === '1,128,255'"));
-             });
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x03, 0x01,
+                      0x80, 0xFF, 0x56, 0x42, 0x00, 0x03, 0x00});
+  ExpectScriptTrue("result.toString() === '1,128,255'");
+
 #if defined(V8_TARGET_LITTLE_ENDIAN)
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x06, 0x00, 0x00, 0x00,
-              0x01, 0x00, 0x80, 0x56, 0x77, 0x00, 0x06},
-             [this](Local<Value> value) {
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "result.toString() === '0,256,-32768'"));
-             });
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x10, 0x00, 0x00,
-              0x00, 0x00, 0x00, 0x00, 0x00, 0xBF, 0x00, 0x00, 0xC0, 0x7F,
-              0x00, 0x00, 0x80, 0x7F, 0x56, 0x66, 0x00, 0x10},
-             [this](Local<Value> value) {
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "result.toString() === '0,-0.5,NaN,Infinity'"));
-             });
+  value = DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x06, 0x00,
+                      0x00, 0x00, 0x01, 0x00, 0x80, 0x56, 0x77, 0x00, 0x06});
+  ExpectScriptTrue("result.toString() === '0,256,-32768'");
+
+  value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x10, 0x00, 0x00,
+                  0x00, 0x00, 0x00, 0x00, 0x00, 0xBF, 0x00, 0x00, 0xC0, 0x7F,
+                  0x00, 0x00, 0x80, 0x7F, 0x56, 0x66, 0x00, 0x10});
+  ExpectScriptTrue("result.toString() === '0,-0.5,NaN,Infinity'");
+
 #endif  // V8_TARGET_LITTLE_ENDIAN
 
   // Array buffer views sharing a buffer should do so on the other side.
   // Similarly, multiple references to the same typed array should be resolved.
-  DecodeTest(
+  value = DecodeTest(
       {0xFF, 0x09, 0x3F, 0x00, 0x6F, 0x3F, 0x01, 0x53, 0x02, 0x75, 0x38, 0x3F,
        0x01, 0x3F, 0x01, 0x42, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -2140,18 +1761,13 @@ TEST_F(ValueSerializerTest, DecodeTypedArray) {
        0x00, 0x56, 0x42, 0x00, 0x20, 0x3F, 0x03, 0x53, 0x04, 0x75, 0x38, 0x5F,
        0x32, 0x3F, 0x03, 0x5E, 0x02, 0x3F, 0x03, 0x53, 0x03, 0x66, 0x33, 0x32,
        0x3F, 0x03, 0x3F, 0x03, 0x5E, 0x01, 0x56, 0x66, 0x04, 0x14, 0x3F, 0x04,
-       0x53, 0x01, 0x62, 0x3F, 0x04, 0x5E, 0x01, 0x7B, 0x04, 0x00},
-      [this](Local<Value> value) {
-        EXPECT_TRUE(
-            EvaluateScriptForResultBool("result.u8 instanceof Uint8Array"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.u8 === result.u8_2"));
-        EXPECT_TRUE(
-            EvaluateScriptForResultBool("result.f32 instanceof Float32Array"));
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "result.u8.buffer === result.f32.buffer"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.f32.byteOffset === 4"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.f32.length === 5"));
-      });
+       0x53, 0x01, 0x62, 0x3F, 0x04, 0x5E, 0x01, 0x7B, 0x04, 0x00});
+  ExpectScriptTrue("result.u8 instanceof Uint8Array");
+  ExpectScriptTrue("result.u8 === result.u8_2");
+  ExpectScriptTrue("result.f32 instanceof Float32Array");
+  ExpectScriptTrue("result.u8.buffer === result.f32.buffer");
+  ExpectScriptTrue("result.f32.byteOffset === 4");
+  ExpectScriptTrue("result.f32.length === 5");
 }
 
 TEST_F(ValueSerializerTest, DecodeInvalidTypedArray) {
@@ -2173,28 +1789,23 @@ TEST_F(ValueSerializerTest, DecodeInvalidTypedArray) {
 }
 
 TEST_F(ValueSerializerTest, RoundTripDataView) {
-  RoundTripTest("new DataView(new ArrayBuffer(4), 1, 2)",
-                [this](Local<Value> value) {
-                  ASSERT_TRUE(value->IsDataView());
-                  EXPECT_EQ(1u, DataView::Cast(*value)->ByteOffset());
-                  EXPECT_EQ(2u, DataView::Cast(*value)->ByteLength());
-                  EXPECT_EQ(4u, DataView::Cast(*value)->Buffer()->ByteLength());
-                  EXPECT_TRUE(EvaluateScriptForResultBool(
-                      "Object.getPrototypeOf(result) === DataView.prototype"));
-                });
+  Local<Value> value = RoundTripTest("new DataView(new ArrayBuffer(4), 1, 2)");
+  ASSERT_TRUE(value->IsDataView());
+  EXPECT_EQ(1u, DataView::Cast(*value)->ByteOffset());
+  EXPECT_EQ(2u, DataView::Cast(*value)->ByteLength());
+  EXPECT_EQ(4u, DataView::Cast(*value)->Buffer()->ByteLength());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === DataView.prototype");
 }
 
 TEST_F(ValueSerializerTest, DecodeDataView) {
-  DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x04, 0x00, 0x00, 0x00,
-              0x00, 0x56, 0x3F, 0x01, 0x02},
-             [this](Local<Value> value) {
-               ASSERT_TRUE(value->IsDataView());
-               EXPECT_EQ(1u, DataView::Cast(*value)->ByteOffset());
-               EXPECT_EQ(2u, DataView::Cast(*value)->ByteLength());
-               EXPECT_EQ(4u, DataView::Cast(*value)->Buffer()->ByteLength());
-               EXPECT_TRUE(EvaluateScriptForResultBool(
-                   "Object.getPrototypeOf(result) === DataView.prototype"));
-             });
+  Local<Value> value =
+      DecodeTest({0xFF, 0x09, 0x3F, 0x00, 0x3F, 0x00, 0x42, 0x04, 0x00, 0x00,
+                  0x00, 0x00, 0x56, 0x3F, 0x01, 0x02});
+  ASSERT_TRUE(value->IsDataView());
+  EXPECT_EQ(1u, DataView::Cast(*value)->ByteOffset());
+  EXPECT_EQ(2u, DataView::Cast(*value)->ByteLength());
+  EXPECT_EQ(4u, DataView::Cast(*value)->Buffer()->ByteLength());
+  ExpectScriptTrue("Object.getPrototypeOf(result) === DataView.prototype");
 }
 
 TEST_F(ValueSerializerTest, DecodeInvalidDataView) {
@@ -2308,35 +1919,28 @@ TEST_F(ValueSerializerTestWithSharedArrayBufferClone,
   EXPECT_CALL(deserializer_delegate_, GetSharedArrayBufferFromId(isolate(), 0U))
       .WillRepeatedly(Return(output_buffer()));
 
-  RoundTripTest([this]() { return input_buffer(); },
-                [this](Local<Value> value) {
-                  ASSERT_TRUE(value->IsSharedArrayBuffer());
-                  EXPECT_EQ(output_buffer(), value);
-                  EXPECT_TRUE(EvaluateScriptForResultBool(
-                      "new Uint8Array(result).toString() === '0,1,128,255'"));
-                });
-  RoundTripTest(
-      [this]() {
-        Local<Object> object = Object::New(isolate());
-        EXPECT_TRUE(object
-                        ->CreateDataProperty(serialization_context(),
-                                             StringFromUtf8("a"),
-                                             input_buffer())
-                        .FromMaybe(false));
-        EXPECT_TRUE(object
-                        ->CreateDataProperty(serialization_context(),
-                                             StringFromUtf8("b"),
-                                             input_buffer())
-                        .FromMaybe(false));
-        return object;
-      },
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "result.a instanceof SharedArrayBuffer"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === result.b"));
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "new Uint8Array(result.a).toString() === '0,1,128,255'"));
-      });
+  Local<Value> value = RoundTripTest(input_buffer());
+  ASSERT_TRUE(value->IsSharedArrayBuffer());
+  EXPECT_EQ(output_buffer(), value);
+  ExpectScriptTrue("new Uint8Array(result).toString() === '0,1,128,255'");
+
+  Local<Object> object;
+  {
+    Context::Scope scope(serialization_context());
+    object = Object::New(isolate());
+    EXPECT_TRUE(object
+                    ->CreateDataProperty(serialization_context(),
+                                         StringFromUtf8("a"), input_buffer())
+                    .FromMaybe(false));
+    EXPECT_TRUE(object
+                    ->CreateDataProperty(serialization_context(),
+                                         StringFromUtf8("b"), input_buffer())
+                    .FromMaybe(false));
+  }
+  value = RoundTripTest(object);
+  ExpectScriptTrue("result.a instanceof SharedArrayBuffer");
+  ExpectScriptTrue("result.a === result.b");
+  ExpectScriptTrue("new Uint8Array(result.a).toString() === '0,1,128,255'");
 }
 
 TEST_F(ValueSerializerTestWithSharedArrayBufferClone,
@@ -2354,23 +1958,20 @@ TEST_F(ValueSerializerTestWithSharedArrayBufferClone,
   EXPECT_CALL(deserializer_delegate_, GetSharedArrayBufferFromId(isolate(), 0U))
       .WillRepeatedly(Return(output_buffer()));
 
-  RoundTripTest(
-      [this]() -> Local<Value> {
-        const int32_t kMaxPages = 1;
-        auto i_isolate = reinterpret_cast<i::Isolate*>(isolate());
-        i::Handle<i::JSArrayBuffer> obj = Utils::OpenHandle(*input_buffer());
-        return Utils::Convert<i::WasmMemoryObject, Value>(
-            i::WasmMemoryObject::New(i_isolate, obj, kMaxPages));
-      },
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "result instanceof WebAssembly.Memory"));
-        EXPECT_TRUE(
-            EvaluateScriptForResultBool("result.buffer.byteLength === 65536"));
-        EXPECT_TRUE(
-            EvaluateScriptForResultBool("new Uint8Array(result.buffer, 0, "
-                                        "4).toString() === '0,1,128,255'"));
-      });
+  Local<Value> input;
+  {
+    Context::Scope scope(serialization_context());
+    const int32_t kMaxPages = 1;
+    i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate());
+    i::Handle<i::JSArrayBuffer> obj = Utils::OpenHandle(*input_buffer());
+    input = Utils::Convert<i::WasmMemoryObject, Value>(
+        i::WasmMemoryObject::New(i_isolate, obj, kMaxPages));
+  }
+  RoundTripTest(input);
+  ExpectScriptTrue("result instanceof WebAssembly.Memory");
+  ExpectScriptTrue("result.buffer.byteLength === 65536");
+  ExpectScriptTrue(
+      "new Uint8Array(result.buffer, 0, 4).toString() === '0,1,128,255'");
 
   i::FLAG_experimental_wasm_threads = flag_was_enabled;
 }
@@ -2471,17 +2072,15 @@ TEST_F(ValueSerializerTestWithHostObject, RoundTripUint32) {
         Local<Value> argv[] = {Integer::NewFromUnsigned(isolate(), value)};
         return NewHostObject(deserialization_context(), arraysize(argv), argv);
       }));
-  RoundTripTest("new ExampleHostObject(42)", [this](Local<Value> value) {
-    ASSERT_TRUE(value->IsObject());
-    ASSERT_TRUE(Object::Cast(*value)->InternalFieldCount());
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "Object.getPrototypeOf(result) === ExampleHostObject.prototype"));
-    EXPECT_TRUE(EvaluateScriptForResultBool("result.value === 42"));
-  });
-  RoundTripTest(
-      "new ExampleHostObject(0xCAFECAFE)", [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.value === 0xCAFECAFE"));
-      });
+  Local<Value> value = RoundTripTest("new ExampleHostObject(42)");
+  ASSERT_TRUE(value->IsObject());
+  ASSERT_TRUE(Object::Cast(*value)->InternalFieldCount());
+  ExpectScriptTrue(
+      "Object.getPrototypeOf(result) === ExampleHostObject.prototype");
+  ExpectScriptTrue("result.value === 42");
+
+  value = RoundTripTest("new ExampleHostObject(0xCAFECAFE)");
+  ExpectScriptTrue("result.value === 0xCAFECAFE");
 }
 
 TEST_F(ValueSerializerTestWithHostObject, RoundTripUint64) {
@@ -2511,21 +2110,17 @@ TEST_F(ValueSerializerTestWithHostObject, RoundTripUint64) {
                                      static_cast<uint32_t>(value_packed))};
         return NewHostObject(deserialization_context(), arraysize(argv), argv);
       }));
-  RoundTripTest("new ExampleHostObject(42, 0)", [this](Local<Value> value) {
-    ASSERT_TRUE(value->IsObject());
-    ASSERT_TRUE(Object::Cast(*value)->InternalFieldCount());
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "Object.getPrototypeOf(result) === ExampleHostObject.prototype"));
-    EXPECT_TRUE(EvaluateScriptForResultBool("result.value === 42"));
-    EXPECT_TRUE(EvaluateScriptForResultBool("result.value2 === 0"));
-  });
-  RoundTripTest(
-      "new ExampleHostObject(0xFFFFFFFF, 0x12345678)",
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.value === 0xFFFFFFFF"));
-        EXPECT_TRUE(
-            EvaluateScriptForResultBool("result.value2 === 0x12345678"));
-      });
+  Local<Value> value = RoundTripTest("new ExampleHostObject(42, 0)");
+  ASSERT_TRUE(value->IsObject());
+  ASSERT_TRUE(Object::Cast(*value)->InternalFieldCount());
+  ExpectScriptTrue(
+      "Object.getPrototypeOf(result) === ExampleHostObject.prototype");
+  ExpectScriptTrue("result.value === 42");
+  ExpectScriptTrue("result.value2 === 0");
+
+  value = RoundTripTest("new ExampleHostObject(0xFFFFFFFF, 0x12345678)");
+  ExpectScriptTrue("result.value === 0xFFFFFFFF");
+  ExpectScriptTrue("result.value2 === 0x12345678");
 }
 
 TEST_F(ValueSerializerTestWithHostObject, RoundTripDouble) {
@@ -2548,22 +2143,21 @@ TEST_F(ValueSerializerTestWithHostObject, RoundTripDouble) {
         Local<Value> argv[] = {Number::New(isolate(), value)};
         return NewHostObject(deserialization_context(), arraysize(argv), argv);
       }));
-  RoundTripTest("new ExampleHostObject(-3.5)", [this](Local<Value> value) {
-    ASSERT_TRUE(value->IsObject());
-    ASSERT_TRUE(Object::Cast(*value)->InternalFieldCount());
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "Object.getPrototypeOf(result) === ExampleHostObject.prototype"));
-    EXPECT_TRUE(EvaluateScriptForResultBool("result.value === -3.5"));
-  });
-  RoundTripTest("new ExampleHostObject(NaN)", [this](Local<Value> value) {
-    EXPECT_TRUE(EvaluateScriptForResultBool("Number.isNaN(result.value)"));
-  });
-  RoundTripTest("new ExampleHostObject(Infinity)", [this](Local<Value> value) {
-    EXPECT_TRUE(EvaluateScriptForResultBool("result.value === Infinity"));
-  });
-  RoundTripTest("new ExampleHostObject(-0)", [this](Local<Value> value) {
-    EXPECT_TRUE(EvaluateScriptForResultBool("1/result.value === -Infinity"));
-  });
+  Local<Value> value = RoundTripTest("new ExampleHostObject(-3.5)");
+  ASSERT_TRUE(value->IsObject());
+  ASSERT_TRUE(Object::Cast(*value)->InternalFieldCount());
+  ExpectScriptTrue(
+      "Object.getPrototypeOf(result) === ExampleHostObject.prototype");
+  ExpectScriptTrue("result.value === -3.5");
+
+  value = RoundTripTest("new ExampleHostObject(NaN)");
+  ExpectScriptTrue("Number.isNaN(result.value)");
+
+  value = RoundTripTest("new ExampleHostObject(Infinity)");
+  ExpectScriptTrue("result.value === Infinity");
+
+  value = RoundTripTest("new ExampleHostObject(-0)");
+  ExpectScriptTrue("1/result.value === -Infinity");
 }
 
 TEST_F(ValueSerializerTestWithHostObject, RoundTripRawBytes) {
@@ -2591,12 +2185,11 @@ TEST_F(ValueSerializerTestWithHostObject, RoundTripRawBytes) {
         }
         return NewHostObject(deserialization_context(), 0, nullptr);
       }));
-  RoundTripTest("new ExampleHostObject()", [this](Local<Value> value) {
-    ASSERT_TRUE(value->IsObject());
-    ASSERT_TRUE(Object::Cast(*value)->InternalFieldCount());
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "Object.getPrototypeOf(result) === ExampleHostObject.prototype"));
-  });
+  Local<Value> value = RoundTripTest("new ExampleHostObject()");
+  ASSERT_TRUE(value->IsObject());
+  ASSERT_TRUE(Object::Cast(*value)->InternalFieldCount());
+  ExpectScriptTrue(
+      "Object.getPrototypeOf(result) === ExampleHostObject.prototype");
 }
 
 TEST_F(ValueSerializerTestWithHostObject, RoundTripSameObject) {
@@ -2613,13 +2206,9 @@ TEST_F(ValueSerializerTestWithHostObject, RoundTripSameObject) {
         EXPECT_TRUE(ReadExampleHostObjectTag());
         return NewHostObject(deserialization_context(), 0, nullptr);
       }));
-  RoundTripTest(
-      "({ a: new ExampleHostObject(), get b() { return this.a; }})",
-      [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "result.a instanceof ExampleHostObject"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === result.b"));
-      });
+  RoundTripTest("({ a: new ExampleHostObject(), get b() { return this.a; }})");
+  ExpectScriptTrue("result.a instanceof ExampleHostObject");
+  ExpectScriptTrue("result.a === result.b");
 }
 
 TEST_F(ValueSerializerTestWithHostObject, DecodeSimpleHostObject) {
@@ -2628,11 +2217,9 @@ TEST_F(ValueSerializerTestWithHostObject, DecodeSimpleHostObject) {
         EXPECT_TRUE(ReadExampleHostObjectTag());
         return NewHostObject(deserialization_context(), 0, nullptr);
       }));
-  DecodeTest(
-      {0xFF, 0x0D, 0x5C, kExampleHostObjectTag}, [this](Local<Value> value) {
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "Object.getPrototypeOf(result) === ExampleHostObject.prototype"));
-      });
+  DecodeTest({0xFF, 0x0D, 0x5C, kExampleHostObjectTag});
+  ExpectScriptTrue(
+      "Object.getPrototypeOf(result) === ExampleHostObject.prototype");
 }
 
 class ValueSerializerTestWithHostArrayBufferView
@@ -2657,14 +2244,10 @@ TEST_F(ValueSerializerTestWithHostArrayBufferView, RoundTripUint8ArrayInput) {
         return NewDummyUint8Array();
       }));
   RoundTripTest(
-      "({ a: new Uint8Array([1, 2, 3]), get b() { return this.a; }})",
-      [this](Local<Value> value) {
-        EXPECT_TRUE(
-            EvaluateScriptForResultBool("result.a instanceof Uint8Array"));
-        EXPECT_TRUE(
-            EvaluateScriptForResultBool("result.a.toString() === '4,5,6'"));
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.a === result.b"));
-      });
+      "({ a: new Uint8Array([1, 2, 3]), get b() { return this.a; }})");
+  ExpectScriptTrue("result.a instanceof Uint8Array");
+  ExpectScriptTrue("result.a.toString() === '4,5,6'");
+  ExpectScriptTrue("result.a === result.b");
 }
 
 // It's expected that WebAssembly has more exhaustive tests elsewhere; this
@@ -2780,6 +2363,7 @@ class ValueSerializerTestWithWasm : public ValueSerializerTest {
   }
 
   Local<WasmCompiledModule> MakeWasm() {
+    Context::Scope scope(serialization_context());
     return WasmCompiledModule::DeserializeOrCompile(
                isolate(), {nullptr, 0},
                {kIncrementerWasm, sizeof(kIncrementerWasm)})
@@ -2787,22 +2371,20 @@ class ValueSerializerTestWithWasm : public ValueSerializerTest {
   }
 
   void ExpectPass() {
-    RoundTripTest(
-        [this]() { return MakeWasm(); },
-        [this](Local<Value> value) {
-          ASSERT_TRUE(value->IsWebAssemblyCompiledModule());
-          EXPECT_TRUE(EvaluateScriptForResultBool(
-              "new WebAssembly.Instance(result).exports.increment(8) === 9"));
-        });
+    Local<Value> value = RoundTripTest(MakeWasm());
+    Context::Scope scope(deserialization_context());
+    ASSERT_TRUE(value->IsWebAssemblyCompiledModule());
+    ExpectScriptTrue(
+        "new WebAssembly.Instance(result).exports.increment(8) === 9");
   }
 
   void ExpectFail() {
-    EncodeTest(
-        [this]() { return MakeWasm(); },
-        [this](const std::vector<uint8_t>& data) { InvalidDecodeTest(data); });
+    const std::vector<uint8_t> data = EncodeTest(MakeWasm());
+    InvalidDecodeTest(data);
   }
 
   Local<Value> GetComplexObjectWithDuplicate() {
+    Context::Scope scope(serialization_context());
     Local<Value> wasm_module = MakeWasm();
     serialization_context()
         ->Global()
@@ -2819,14 +2401,13 @@ class ValueSerializerTestWithWasm : public ValueSerializerTest {
 
   void VerifyComplexObject(Local<Value> value) {
     ASSERT_TRUE(value->IsObject());
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "result.mod1 instanceof WebAssembly.Module"));
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "result.mod2 instanceof WebAssembly.Module"));
-    EXPECT_TRUE(EvaluateScriptForResultBool("result.num === 2"));
+    ExpectScriptTrue("result.mod1 instanceof WebAssembly.Module");
+    ExpectScriptTrue("result.mod2 instanceof WebAssembly.Module");
+    ExpectScriptTrue("result.num === 2");
   }
 
   Local<Value> GetComplexObjectWithMany() {
+    Context::Scope scope(serialization_context());
     Local<Value> wasm_module1 = MakeWasm();
     Local<Value> wasm_module2 = MakeWasm();
     serialization_context()
@@ -2868,27 +2449,22 @@ const char* ValueSerializerTestWithWasm::kUnsupportedSerialization =
 // embedder must decide serialization policy.
 TEST_F(ValueSerializerTestWithWasm, DefaultSerializationDelegate) {
   EnableThrowingSerializer();
-  InvalidEncodeTest(
-      [this]() { return MakeWasm(); },
-      [](Local<Message> message) {
-        size_t msg_len = static_cast<size_t>(message->Get()->Length());
-        std::unique_ptr<char[]> buff(new char[msg_len + 1]);
-        message->Get()->WriteOneByte(reinterpret_cast<uint8_t*>(buff.get()));
-        // the message ends with the custom error string
-        size_t custom_msg_len = strlen(kUnsupportedSerialization);
-        ASSERT_GE(msg_len, custom_msg_len);
-        size_t start_pos = msg_len - custom_msg_len;
-        ASSERT_EQ(strcmp(&buff.get()[start_pos], kUnsupportedSerialization), 0);
-      });
+  Local<Message> message = InvalidEncodeTest(MakeWasm());
+  size_t msg_len = static_cast<size_t>(message->Get()->Length());
+  std::unique_ptr<char[]> buff(new char[msg_len + 1]);
+  message->Get()->WriteOneByte(reinterpret_cast<uint8_t*>(buff.get()));
+  // the message ends with the custom error string
+  size_t custom_msg_len = strlen(kUnsupportedSerialization);
+  ASSERT_GE(msg_len, custom_msg_len);
+  size_t start_pos = msg_len - custom_msg_len;
+  ASSERT_EQ(strcmp(&buff.get()[start_pos], kUnsupportedSerialization), 0);
 }
 
 // The default deserializer throws if wasm transfer is attempted
 TEST_F(ValueSerializerTestWithWasm, DefaultDeserializationDelegate) {
   EnableTransferSerialization();
   EnableDefaultDeserializer();
-  EncodeTest(
-      [this]() { return MakeWasm(); },
-      [this](const std::vector<uint8_t>& data) { InvalidDecodeTest(data); });
+  ExpectFail();
 }
 
 // We only want to allow deserialization through
@@ -2923,43 +2499,31 @@ TEST_F(ValueSerializerTestWithWasm, CannotTransferWasmWhenExpectingInline) {
 TEST_F(ValueSerializerTestWithWasm, ComplexObjectDuplicateTransfer) {
   EnableTransferSerialization();
   EnableTransferDeserialization();
-  RoundTripTest(
-      [this]() { return GetComplexObjectWithDuplicate(); },
-      [this](Local<Value> value) {
-        VerifyComplexObject(value);
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.mod1 === result.mod2"));
-      });
+  Local<Value> value = RoundTripTest(GetComplexObjectWithDuplicate());
+  VerifyComplexObject(value);
+  ExpectScriptTrue("result.mod1 === result.mod2");
 }
 
 TEST_F(ValueSerializerTestWithWasm, ComplexObjectDuplicateInline) {
   SetExpectInlineWasm(true);
-  RoundTripTest(
-      [this]() { return GetComplexObjectWithDuplicate(); },
-      [this](Local<Value> value) {
-        VerifyComplexObject(value);
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.mod1 === result.mod2"));
-      });
+  Local<Value> value = RoundTripTest(GetComplexObjectWithDuplicate());
+  VerifyComplexObject(value);
+  ExpectScriptTrue("result.mod1 === result.mod2");
 }
 
 TEST_F(ValueSerializerTestWithWasm, ComplexObjectWithManyTransfer) {
   EnableTransferSerialization();
   EnableTransferDeserialization();
-  RoundTripTest(
-      [this]() { return GetComplexObjectWithMany(); },
-      [this](Local<Value> value) {
-        VerifyComplexObject(value);
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.mod1 != result.mod2"));
-      });
+  Local<Value> value = RoundTripTest(GetComplexObjectWithMany());
+  VerifyComplexObject(value);
+  ExpectScriptTrue("result.mod1 != result.mod2");
 }
 
 TEST_F(ValueSerializerTestWithWasm, ComplexObjectWithManyInline) {
   SetExpectInlineWasm(true);
-  RoundTripTest(
-      [this]() { return GetComplexObjectWithMany(); },
-      [this](Local<Value> value) {
-        VerifyComplexObject(value);
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.mod1 != result.mod2"));
-      });
+  Local<Value> value = RoundTripTest(GetComplexObjectWithMany());
+  VerifyComplexObject(value);
+  ExpectScriptTrue("result.mod1 != result.mod2");
 }
 
 // As produced around Chrome 56.
@@ -3028,11 +2592,10 @@ TEST_F(ValueSerializerTestWithWasm, DecodeWasmModule) {
   std::vector<uint8_t> raw(
       kSerializedIncrementerWasm,
       kSerializedIncrementerWasm + sizeof(kSerializedIncrementerWasm));
-  DecodeTest(raw, [this](Local<Value> value) {
-    ASSERT_TRUE(value->IsWebAssemblyCompiledModule());
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "new WebAssembly.Instance(result).exports.increment(8) === 9"));
-  });
+  Local<Value> value = DecodeTest(raw);
+  ASSERT_TRUE(value->IsWebAssemblyCompiledModule());
+  ExpectScriptTrue(
+      "new WebAssembly.Instance(result).exports.increment(8) === 9");
 }
 
 // As above, but with empty compiled data. Should work due to fallback to wire
@@ -3050,11 +2613,10 @@ TEST_F(ValueSerializerTestWithWasm, DecodeWasmModuleWithInvalidCompiledData) {
       kSerializedIncrementerWasmWithInvalidCompiledData,
       kSerializedIncrementerWasmWithInvalidCompiledData +
           sizeof(kSerializedIncrementerWasmWithInvalidCompiledData));
-  DecodeTest(raw, [this](Local<Value> value) {
-    ASSERT_TRUE(value->IsWebAssemblyCompiledModule());
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "new WebAssembly.Instance(result).exports.increment(8) === 9"));
-  });
+  Local<Value> value = DecodeTest(raw);
+  ASSERT_TRUE(value->IsWebAssemblyCompiledModule());
+  ExpectScriptTrue(
+      "new WebAssembly.Instance(result).exports.increment(8) === 9");
 }
 
 // As above, but also with empty wire data. Should fail.