AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity
81008e1752
v8/test/unittests/objects/value-serializer-unittest.cc
Clemens Backes 3f9ff062b0 Reland "[no-wasm] Exclude src/wasm from compilation" 
This is a reland of 80f5dfda01. A condition
in pipeline.cc was inverted, which lead to a CSA verifier error.

Original change's description:
> [no-wasm] Exclude src/wasm from compilation
>
> This is the biggest chunk, including
> - all of src/wasm,
> - torque file for wasm objects,
> - torque file for wasm builtins,
> - wasm builtins,
> - wasm runtime functions,
> - int64 lowering,
> - simd scala lowering,
> - WasmGraphBuilder (TF graph construction for wasm),
> - wasm frame types,
> - wasm interrupts,
> - the JSWasmCall opcode,
> - wasm backing store allocation.
>
> Those components are all recursively entangled, so I found no way to
> split this change up further.
>
> Some includes that were recursively included by wasm headers needed to
> be added explicitly now.
>
> backing-store-unittest.cc is renamed to wasm-backing-store-unittest.cc
> because it only tests wasm backing stores. This file is excluded from
> no-wasm builds then.
>
> R=jkummerow@chromium.org, jgruber@chromium.org, mlippautz@chromium.org, petermarshall@chromium.org
>
> Bug: v8:11238
> Change-Id: I7558f2d12d2dd6c65128c4de7b79173668c80b2b
> Cq-Include-Trybots: luci.v8.try:v8_linux64_no_wasm_compile_rel
> Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2742955
> Commit-Queue: Clemens Backes <clemensb@chromium.org>
> Reviewed-by: Peter Marshall <petermarshall@chromium.org>
> Reviewed-by: Toon Verwaest <verwaest@chromium.org>
> Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
> Reviewed-by: Jakob Kummerow <jkummerow@chromium.org>
> Reviewed-by: Jakob Gruber <jgruber@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#73344}

TBR=jgruber@chromium.org

Bug: v8:11238
Change-Id: I20bd2847a59c68738b5a336cd42582b7b1499585
Cq-Include-Trybots: luci.v8.try:v8_linux64_no_wasm_compile_rel
Cq-Include-Trybots: luci.v8.try:v8_linux_verify_csa_rel_ng
Cq-Include-Trybots: luci.v8.try:v8_linux64_verify_csa_rel_ng
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2752867
Reviewed-by: Clemens Backes <clemensb@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Commit-Queue: Clemens Backes <clemensb@chromium.org>
Cr-Commit-Position: refs/heads/master@{#73348}
2021-03-11 14:29:26 +00:00

2895 lines
111 KiB
C++
Raw Blame History

// Copyright 2016 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/objects/value-serializer.h"
#include <algorithm>
#include <string>
#include "include/v8.h"
#include "src/api/api-inl.h"
#include "src/base/build_config.h"
#include "src/objects/backing-store.h"
#include "src/objects/objects-inl.h"
#include "test/unittests/test-utils.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#if V8_ENABLE_WEBASSEMBLY
#include "src/wasm/wasm-engine.h"
#include "src/wasm/wasm-objects.h"
#include "src/wasm/wasm-result.h"
#endif // V8_ENABLE_WEBASSEMBLY
namespace v8 {
namespace {
using ::testing::_;
using ::testing::Invoke;
using ::testing::Return;
class ValueSerializerTest : public TestWithIsolate {
public:
ValueSerializerTest(const ValueSerializerTest&) = delete;
ValueSerializerTest& operator=(const ValueSerializerTest&) = delete;
protected:
ValueSerializerTest()
: serialization_context_(Context::New(isolate())),
deserialization_context_(Context::New(isolate())) {
// Create a host object type that can be tested through
// serialization/deserialization delegates below.
Local<FunctionTemplate> function_template = v8::FunctionTemplate::New(
isolate(), [](const FunctionCallbackInfo<Value>& args) {
args.Holder()->SetInternalField(0, args[0]);
args.Holder()->SetInternalField(1, args[1]);
});
function_template->InstanceTemplate()->SetInternalFieldCount(2);
function_template->InstanceTemplate()->SetAccessor(
StringFromUtf8("value"),
[](Local<String> property, const PropertyCallbackInfo<Value>& args) {
args.GetReturnValue().Set(args.Holder()->GetInternalField(0));
});
function_template->InstanceTemplate()->SetAccessor(
StringFromUtf8("value2"),
[](Local<String> property, const PropertyCallbackInfo<Value>& args) {
args.GetReturnValue().Set(args.Holder()->GetInternalField(1));
});
for (Local<Context> context :
{serialization_context_, deserialization_context_}) {
context->Global()
->CreateDataProperty(
context, StringFromUtf8("ExampleHostObject"),
function_template->GetFunction(context).ToLocalChecked())
.ToChecked();
}
host_object_constructor_template_ = function_template;
isolate_ = reinterpret_cast<i::Isolate*>(isolate());
}
~ValueSerializerTest() override {
// In some cases unhandled scheduled exceptions from current test produce
// that Context::New(isolate()) from next test's constructor returns NULL.
// In order to prevent that, we added destructor which will clear scheduled
// exceptions just for the current test from test case.
if (isolate_->has_scheduled_exception()) {
isolate_->clear_scheduled_exception();
}
}
const Local<Context>& serialization_context() {
return serialization_context_;
}
const Local<Context>& deserialization_context() {
return deserialization_context_;
}
// Overridden in more specific fixtures.
virtual ValueSerializer::Delegate* GetSerializerDelegate() { return nullptr; }
virtual void BeforeEncode(ValueSerializer*) {}
virtual ValueDeserializer::Delegate* GetDeserializerDelegate() {
return nullptr;
}
virtual void BeforeDecode(ValueDeserializer*) {}
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.
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) {
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) {
Local<Context> context = serialization_context();
ValueSerializer serializer(isolate(), GetSerializerDelegate());
BeforeEncode(&serializer);
serializer.WriteHeader();
if (!serializer.WriteValue(context, value).FromMaybe(false)) {
return Nothing<std::vector<uint8_t>>();
}
std::pair<uint8_t*, size_t> buffer = serializer.Release();
std::vector<uint8_t> result(buffer.first, buffer.first + buffer.second);
if (auto* delegate = GetSerializerDelegate())
delegate->FreeBufferMemory(buffer.first);
else
free(buffer.first);
return Just(std::move(result));
}
std::vector<uint8_t> EncodeTest(Local<Value> input_value) {
Context::Scope scope(serialization_context());
TryCatch try_catch(isolate());
std::vector<uint8_t> 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;
}
std::vector<uint8_t> EncodeTest(const char* source) {
return EncodeTest(EvaluateScriptForInput(source));
}
v8::Local<v8::Message> InvalidEncodeTest(Local<Value> input_value) {
Context::Scope scope(serialization_context());
TryCatch try_catch(isolate());
CHECK(DoEncode(input_value).IsNothing());
return try_catch.Message();
}
v8::Local<v8::Message> InvalidEncodeTest(const char* source) {
return InvalidEncodeTest(EvaluateScriptForInput(source));
}
Local<Value> DecodeTest(const std::vector<uint8_t>& data) {
Local<Context> context = deserialization_context();
Context::Scope scope(context);
TryCatch try_catch(isolate());
ValueDeserializer deserializer(isolate(), &data[0],
static_cast<int>(data.size()),
GetDeserializerDelegate());
deserializer.SetSupportsLegacyWireFormat(true);
BeforeDecode(&deserializer);
CHECK(deserializer.ReadHeader(context).FromMaybe(false));
Local<Value> result;
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;
}
Local<Value> DecodeTestForVersion0(const std::vector<uint8_t>& data) {
Local<Context> context = deserialization_context();
Context::Scope scope(context);
TryCatch try_catch(isolate());
ValueDeserializer deserializer(isolate(), &data[0],
static_cast<int>(data.size()),
GetDeserializerDelegate());
deserializer.SetSupportsLegacyWireFormat(true);
BeforeDecode(&deserializer);
CHECK(deserializer.ReadHeader(context).FromMaybe(false));
CHECK_EQ(0u, deserializer.GetWireFormatVersion());
Local<Value> result;
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) {
Local<Context> context = deserialization_context();
Context::Scope scope(context);
TryCatch try_catch(isolate());
ValueDeserializer deserializer(isolate(), &data[0],
static_cast<int>(data.size()),
GetDeserializerDelegate());
deserializer.SetSupportsLegacyWireFormat(true);
BeforeDecode(&deserializer);
Maybe<bool> header_result = deserializer.ReadHeader(context);
if (header_result.IsNothing()) {
EXPECT_TRUE(try_catch.HasCaught());
return;
}
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();
}
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();
EXPECT_TRUE(value->BooleanValue(isolate()));
}
Local<String> StringFromUtf8(const char* source) {
return String::NewFromUtf8(isolate(), source).ToLocalChecked();
}
std::string Utf8Value(Local<Value> value) {
String::Utf8Value utf8(isolate(), value);
return std::string(*utf8, utf8.length());
}
Local<Object> NewHostObject(Local<Context> context, int argc,
Local<Value> argv[]) {
return host_object_constructor_template_->GetFunction(context)
.ToLocalChecked()
->NewInstance(context, argc, argv)
.ToLocalChecked();
}
Local<Object> NewDummyUint8Array() {
static uint8_t data[] = {4, 5, 6};
std::unique_ptr<v8::BackingStore> backing_store =
ArrayBuffer::NewBackingStore(
data, sizeof(data), [](void*, size_t, void*) {}, nullptr);
Local<ArrayBuffer> ab =
ArrayBuffer::New(isolate(), std::move(backing_store));
return Uint8Array::New(ab, 0, sizeof(data));
}
private:
Local<Context> serialization_context_;
Local<Context> deserialization_context_;
Local<FunctionTemplate> host_object_constructor_template_;
i::Isolate* isolate_;
};
TEST_F(ValueSerializerTest, DecodeInvalid) {
// Version tag but no content.
InvalidDecodeTest({0xFF});
// Version too large.
InvalidDecodeTest({0xFF, 0x7F, 0x5F});
// Nonsense tag.
InvalidDecodeTest({0xFF, 0x09, 0xDD});
}
TEST_F(ValueSerializerTest, RoundTripOddball) {
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.
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.
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).
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, EncodeArrayStackOverflow) {
InvalidEncodeTest("var a = []; for (var i = 0; i < 1E5; i++) a = [a]; a");
}
TEST_F(ValueSerializerTest, EncodeObjectStackOverflow) {
InvalidEncodeTest("var a = {}; for (var i = 0; i < 1E5; i++) a = {a}; a");
}
TEST_F(ValueSerializerTest, DecodeArrayStackOverflow) {
static const int nesting_level = 1E5;
std::vector<uint8_t> payload;
// Header.
payload.push_back(0xFF);
payload.push_back(0x0D);
// Nested arrays, each with one element.
for (int i = 0; i < nesting_level; i++) {
payload.push_back(0x41);
payload.push_back(0x01);
}
// Innermost array is empty.
payload.push_back(0x41);
payload.push_back(0x00);
payload.push_back(0x24);
payload.push_back(0x00);
payload.push_back(0x00);
// Close nesting.
for (int i = 0; i < nesting_level; i++) {
payload.push_back(0x24);
payload.push_back(0x00);
payload.push_back(0x01);
}
InvalidDecodeTest(payload);
}
TEST_F(ValueSerializerTest, DecodeObjectStackOverflow) {
static const int nesting_level = 1E5;
std::vector<uint8_t> payload;
// Header.
payload.push_back(0xFF);
payload.push_back(0x0D);
// Nested objects, each with one property 'a'.
for (int i = 0; i < nesting_level; i++) {
payload.push_back(0x6F);
payload.push_back(0x22);
payload.push_back(0x01);
payload.push_back(0x61);
}
// Innermost array is empty.
payload.push_back(0x6F);
payload.push_back(0x7B);
payload.push_back(0x00);
// Close nesting.
for (int i = 0; i < nesting_level; i++) {
payload.push_back(0x7B);
payload.push_back(0x01);
}
InvalidDecodeTest(payload);
}
TEST_F(ValueSerializerTest, DecodeVerifyObjectCount) {
static const int nesting_level = 1E5;
std::vector<uint8_t> payload;
// Header.
payload.push_back(0xFF);
payload.push_back(0x0D);
// Repeat SerializationTag:kVerifyObjectCount. This leads to stack overflow.
for (int i = 0; i < nesting_level; i++) {
payload.push_back(0x3F);
payload.push_back(0x01);
}
InvalidDecodeTest(payload);
}
TEST_F(ValueSerializerTest, RoundTripNumber) {
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)
Local<Value> value = DecodeTest({0xFF, 0x09, 0x49, 0x54});
ASSERT_TRUE(value->IsInt32());
EXPECT_EQ(42, Int32::Cast(*value)->Value());
// 42 varint encoded (unsigned)
value = DecodeTest({0xFF, 0x09, 0x55, 0x2A});
ASSERT_TRUE(value->IsInt32());
EXPECT_EQ(42, Int32::Cast(*value)->Value());
// 160 zig-zag encoded (signed)
value = DecodeTest({0xFF, 0x09, 0x49, 0xC0, 0x02});
ASSERT_TRUE(value->IsInt32());
ASSERT_EQ(160, Int32::Cast(*value)->Value());
// 160 varint encoded (unsigned)
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
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
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
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.
}
TEST_F(ValueSerializerTest, RoundTripBigInt) {
Local<Value> value = RoundTripTest(BigInt::New(isolate(), -42));
ASSERT_TRUE(value->IsBigInt());
ExpectScriptTrue("result === -42n");
value = RoundTripTest(BigInt::New(isolate(), 42));
ExpectScriptTrue("result === 42n");
value = RoundTripTest(BigInt::New(isolate(), 0));
ExpectScriptTrue("result === 0n");
value = RoundTripTest("0x1234567890abcdef777888999n");
ExpectScriptTrue("result === 0x1234567890abcdef777888999n");
value = RoundTripTest("-0x1234567890abcdef777888999123n");
ExpectScriptTrue("result === -0x1234567890abcdef777888999123n");
Context::Scope scope(serialization_context());
value = RoundTripTest(BigIntObject::New(isolate(), 23));
ASSERT_TRUE(value->IsBigIntObject());
ExpectScriptTrue("result == 23n");
}
TEST_F(ValueSerializerTest, DecodeBigInt) {
Local<Value> value = DecodeTest({
0xFF, 0x0D, // Version 13
0x5A, // BigInt
0x08, // Bitfield: sign = false, bytelength = 4
0x2A, 0x00, 0x00, 0x00, // Digit: 42
});
ASSERT_TRUE(value->IsBigInt());
ExpectScriptTrue("result === 42n");
value = DecodeTest({
0xFF, 0x0D, // Version 13
0x7A, // BigIntObject
0x11, // Bitfield: sign = true, bytelength = 8
0x2A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // Digit: 42
});
ASSERT_TRUE(value->IsBigIntObject());
ExpectScriptTrue("result == -42n");
value = DecodeTest({
0xFF, 0x0D, // Version 13
0x5A, // BigInt
0x10, // Bitfield: sign = false, bytelength = 8
0xEF, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12 // Digit(s).
});
ExpectScriptTrue("result === 0x1234567890abcdefn");
value = DecodeTest({0xFF, 0x0D, // Version 13
0x5A, // BigInt
0x17, // Bitfield: sign = true, bytelength = 11
0xEF, 0xCD, 0xAB, 0x90, // Digits.
0x78, 0x56, 0x34, 0x12, 0x33, 0x44, 0x55});
ExpectScriptTrue("result === -0x5544331234567890abcdefn");
value = DecodeTest({
0xFF, 0x0D, // Version 13
0x5A, // BigInt
0x02, // Bitfield: sign = false, bytelength = 1
0x2A, // Digit: 42
});
ExpectScriptTrue("result === 42n");
}
// String constants (in UTF-8) used for string encoding tests.
static const char kHelloString[] = "Hello";
static const char kQuebecString[] = "\x51\x75\xC3\xA9\x62\x65\x63";
static const char kEmojiString[] = "\xF0\x9F\x91\x8A";
TEST_F(ValueSerializerTest, RoundTripString) {
Local<Value> value = RoundTripTest(String::Empty(isolate()));
ASSERT_TRUE(value->IsString());
EXPECT_EQ(0, String::Cast(*value)->Length());
// Inside ASCII.
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.
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).
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.
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).
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)
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.
}
TEST_F(ValueSerializerTest, DecodeInvalidString) {
// UTF-8 string with too few bytes available.
InvalidDecodeTest({0xFF, 0x09, 0x53, 0x10, 'v', '8'});
// One-byte string with too few bytes available.
InvalidDecodeTest({0xFF, 0x0A, 0x22, 0x10, 'v', '8'});
#if defined(V8_TARGET_LITTLE_ENDIAN)
// Two-byte string with too few bytes available.
InvalidDecodeTest({0xFF, 0x09, 0x63, 0x10, 'v', '\0', '8', '\0'});
// Two-byte string with an odd byte length.
InvalidDecodeTest({0xFF, 0x09, 0x63, 0x03, 'v', '\0', '8'});
#endif
// TODO(jbroman): The same for big-endian systems.
}
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.
// 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.
Local<Value> value = RoundTripTest("({})");
ASSERT_TRUE(value->IsObject());
ExpectScriptTrue("Object.getPrototypeOf(result) === Object.prototype");
ExpectScriptTrue("Object.getOwnPropertyNames(result).length === 0");
// String key.
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).
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.
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.
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.
value = RoundTripTest("var y = {}; y.self = y; y;");
ASSERT_TRUE(value->IsObject());
ExpectScriptTrue("result === result.self");
}
TEST_F(ValueSerializerTest, DecodeDictionaryObject) {
// Empty object.
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.
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).
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.
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.
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.
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) {
// Objects which would need conversion to string shouldn't be present as
// object keys. The serializer would have obtained them from the own property
// keys list, which should only contain names and indices.
InvalidDecodeTest(
{0xFF, 0x09, 0x6F, 0x61, 0x00, 0x40, 0x00, 0x00, 0x7B, 0x01});
}
TEST_F(ValueSerializerTest, RoundTripOnlyOwnEnumerableStringKeys) {
// Only "own" properties should be serialized, not ones on the prototype.
Local<Value> value = RoundTripTest("var x = {}; x.__proto__ = {a: 4}; x;");
ExpectScriptTrue("!('a' in result)");
// Only enumerable properties should be serialized.
value = RoundTripTest(
"var x = {};"
"Object.defineProperty(x, 'a', {value: 1, enumerable: false});"
"x;");
ExpectScriptTrue("!('a' in result)");
// Symbol keys should not be serialized.
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.
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.
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.
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.
value = RoundTripTest(
"({ get a() {"
" Object.defineProperty(this, 'b', {value: 2, enumerable: false});"
"}, 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.
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.
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) {
// A case which should run on the fast path, and should reach all of the
// different cases:
// 1. no known transition (first time creating this kind of object)
// 2. expected transitions match to end
// 3. transition partially matches, but falls back due to new property 'w'
// 4. transition to 'z' is now a full transition (needs to be looked up)
// 5. same for 'w'
// 6. new property after complex transition succeeded
// 7. new property after complex transition failed (due to new property)
RoundTripJSON(
"[{\"x\":1,\"y\":2,\"z\":3}"
",{\"x\":4,\"y\":5,\"z\":6}"
",{\"x\":5,\"y\":6,\"w\":7}"
",{\"x\":6,\"y\":7,\"z\":8}"
",{\"x\":0,\"y\":0,\"w\":0}"
",{\"x\":3,\"y\":1,\"w\":4,\"z\":1}"
",{\"x\":5,\"y\":9,\"k\":2,\"z\":6}]");
// A simpler case that uses two-byte strings.
RoundTripJSON(
"[{\"\xF0\x9F\x91\x8A\":1,\"\xF0\x9F\x91\x8B\":2}"
",{\"\xF0\x9F\x91\x8A\":3,\"\xF0\x9F\x91\x8C\":4}"
",{\"\xF0\x9F\x91\x8A\":5,\"\xF0\x9F\x91\x9B\":6}]");
}
TEST_F(ValueSerializerTest, DecodeDictionaryObjectVersion0) {
// Empty object.
Local<Value> value = DecodeTestForVersion0({0x7B, 0x00});
ASSERT_TRUE(value->IsObject());
ExpectScriptTrue("Object.getPrototypeOf(result) === Object.prototype");
ExpectScriptTrue("Object.getOwnPropertyNames(result).length === 0");
// String key.
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).
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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) {
// So large it couldn't exist in the V8 heap, and its size couldn't fit in a
// SMI on 32-bit systems (2^30).
InvalidDecodeTest({0xFF, 0x09, 0x41, 0x80, 0x80, 0x80, 0x80, 0x04});
// Not so large, but there isn't enough data left in the buffer.
InvalidDecodeTest({0xFF, 0x09, 0x41, 0x01});
}
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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).
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.
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.
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) {
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)
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
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
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) {
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) {
// This is a roundabout way of getting an instance of Symbol.
InvalidEncodeTest("Object.valueOf.apply(Symbol())");
}
TEST_F(ValueSerializerTest, DecodeValueObjects) {
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)
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
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
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.
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) {
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) {
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.
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) {
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, 0xFF});
}
TEST_F(ValueSerializerTest, DecodeLinearRegExp) {
bool flag_was_enabled = i::FLAG_enable_experimental_regexp_engine;
// The last byte encodes the regexp flags.
std::vector<uint8_t> regexp_encoding = {0xFF, 0x09, 0x3F, 0x00, 0x52,
0x03, 0x66, 0x6F, 0x6F, 0x6D};
i::FLAG_enable_experimental_regexp_engine = true;
Local<Value> value = DecodeTest(regexp_encoding);
ASSERT_TRUE(value->IsRegExp());
ExpectScriptTrue("Object.getPrototypeOf(result) === RegExp.prototype");
ExpectScriptTrue("result.toString() === '/foo/glmsy'");
i::FLAG_enable_experimental_regexp_engine = false;
InvalidDecodeTest(regexp_encoding);
i::FLAG_enable_experimental_regexp_engine = flag_was_enabled;
}
TEST_F(ValueSerializerTest, DecodeHasIndicesRegExp) {
bool flag_was_enabled = i::FLAG_harmony_regexp_match_indices;
// The last byte encodes the regexp flags.
std::vector<uint8_t> regexp_encoding = {0xFF, 0x09, 0x3F, 0x00, 0x52, 0x03,
0x66, 0x6F, 0x6F, 0xAD, 0x01};
i::FLAG_harmony_regexp_match_indices = true;
Local<Value> value = DecodeTest(regexp_encoding);
ASSERT_TRUE(value->IsRegExp());
ExpectScriptTrue("Object.getPrototypeOf(result) === RegExp.prototype");
ExpectScriptTrue("result.toString() === '/foo/dgmsy'");
i::FLAG_harmony_regexp_match_indices = false;
InvalidDecodeTest(regexp_encoding);
i::FLAG_harmony_regexp_match_indices = flag_was_enabled;
}
TEST_F(ValueSerializerTest, RoundTripMap) {
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.
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) {
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.
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.
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.
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) {
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.
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) {
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.
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.
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.
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) {
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) {
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) {
InvalidDecodeTest({0xFF, 0x09, 0x42, 0xFF, 0xFF, 0x00});
}
// An array buffer allocator that never has available memory.
class OOMArrayBufferAllocator : public ArrayBuffer::Allocator {
public:
void* Allocate(size_t) override { return nullptr; }
void* AllocateUninitialized(size_t) override { return nullptr; }
void Free(void*, size_t) override {}
};
TEST_F(ValueSerializerTest, DecodeArrayBufferOOM) {
// This test uses less of the harness, because it has to customize the
// isolate.
OOMArrayBufferAllocator allocator;
Isolate::CreateParams params;
params.array_buffer_allocator = &allocator;
Isolate* isolate = Isolate::New(params);
{
Isolate::Scope isolate_scope(isolate);
HandleScope handle_scope(isolate);
Local<Context> context = Context::New(isolate);
Context::Scope context_scope(context);
TryCatch try_catch(isolate);
const std::vector<uint8_t> data = {0xFF, 0x09, 0x3F, 0x00, 0x42,
0x03, 0x00, 0x80, 0xFF, 0x00};
ValueDeserializer deserializer(isolate, &data[0],
static_cast<int>(data.size()), nullptr);
deserializer.SetSupportsLegacyWireFormat(true);
ASSERT_TRUE(deserializer.ReadHeader(context).FromMaybe(false));
ASSERT_FALSE(try_catch.HasCaught());
EXPECT_TRUE(deserializer.ReadValue(context).IsEmpty());
EXPECT_TRUE(try_catch.HasCaught());
}
isolate->Dispose();
}
// Includes an ArrayBuffer wrapper marked for transfer from the serialization
// context to the deserialization context.
class ValueSerializerTestWithArrayBufferTransfer : public ValueSerializerTest {
protected:
static const size_t kTestByteLength = 4;
ValueSerializerTestWithArrayBufferTransfer() {
{
Context::Scope scope(serialization_context());
input_buffer_ = ArrayBuffer::New(isolate(), 0);
}
{
Context::Scope scope(deserialization_context());
output_buffer_ = ArrayBuffer::New(isolate(), kTestByteLength);
const uint8_t data[kTestByteLength] = {0x00, 0x01, 0x80, 0xFF};
memcpy(output_buffer_->GetBackingStore()->Data(), data, kTestByteLength);
}
}
const Local<ArrayBuffer>& input_buffer() { return input_buffer_; }
const Local<ArrayBuffer>& output_buffer() { return output_buffer_; }
void BeforeEncode(ValueSerializer* serializer) override {
serializer->TransferArrayBuffer(0, input_buffer_);
}
void BeforeDecode(ValueDeserializer* deserializer) override {
deserializer->TransferArrayBuffer(0, output_buffer_);
}
private:
Local<ArrayBuffer> input_buffer_;
Local<ArrayBuffer> output_buffer_;
};
TEST_F(ValueSerializerTestWithArrayBufferTransfer,
RoundTripArrayBufferTransfer) {
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.
Local<Value> value;
#define TYPED_ARRAY_ROUND_TRIP_TEST(Type, type, TYPE, ctype) \
value = RoundTripTest("new " #Type "Array(2)"); \
ASSERT_TRUE(value->Is##Type##Array()); \
EXPECT_EQ(2u * sizeof(ctype), 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_ROUND_TRIP_TEST
// Check that values of various kinds are suitably preserved.
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.
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.
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)
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.
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)
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.
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,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
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});
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) {
// Byte offset out of range.
InvalidDecodeTest(
{0xFF, 0x09, 0x42, 0x02, 0x00, 0x00, 0x56, 0x42, 0x03, 0x01});
// Byte offset in range, offset + length out of range.
InvalidDecodeTest(
{0xFF, 0x09, 0x42, 0x02, 0x00, 0x00, 0x56, 0x42, 0x01, 0x03});
// Byte offset not divisible by element size.
InvalidDecodeTest(
{0xFF, 0x09, 0x42, 0x04, 0x00, 0x00, 0x00, 0x00, 0x56, 0x77, 0x01, 0x02});
// Byte length not divisible by element size.
InvalidDecodeTest(
{0xFF, 0x09, 0x42, 0x04, 0x00, 0x00, 0x00, 0x00, 0x56, 0x77, 0x02, 0x01});
// Invalid view type (0xFF).
InvalidDecodeTest(
{0xFF, 0x09, 0x42, 0x02, 0x00, 0x00, 0x56, 0xFF, 0x01, 0x01});
}
TEST_F(ValueSerializerTest, RoundTripDataView) {
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) {
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, DecodeArrayWithLengthProperty1) {
InvalidDecodeTest({0xff, 0x0d, 0x41, 0x03, 0x49, 0x02, 0x49, 0x04,
0x49, 0x06, 0x22, 0x06, 0x6c, 0x65, 0x6e, 0x67,
0x74, 0x68, 0x49, 0x02, 0x24, 0x01, 0x03});
}
TEST_F(ValueSerializerTest, DecodeArrayWithLengthProperty2) {
InvalidDecodeTest({0xff, 0x0d, 0x41, 0x03, 0x49, 0x02, 0x49, 0x04,
0x49, 0x06, 0x22, 0x06, 0x6c, 0x65, 0x6e, 0x67,
0x74, 0x68, 0x6f, 0x7b, 0x00, 0x24, 0x01, 0x03});
}
TEST_F(ValueSerializerTest, DecodeInvalidDataView) {
// Byte offset out of range.
InvalidDecodeTest(
{0xFF, 0x09, 0x42, 0x02, 0x00, 0x00, 0x56, 0x3F, 0x03, 0x01});
// Byte offset in range, offset + length out of range.
InvalidDecodeTest(
{0xFF, 0x09, 0x42, 0x02, 0x00, 0x00, 0x56, 0x3F, 0x01, 0x03});
}
class ValueSerializerTestWithSharedArrayBufferClone
: public ValueSerializerTest {
protected:
ValueSerializerTestWithSharedArrayBufferClone()
: serializer_delegate_(this), deserializer_delegate_(this) {}
void InitializeData(const std::vector<uint8_t>& data, bool is_wasm_memory) {
data_ = data;
{
Context::Scope scope(serialization_context());
input_buffer_ =
NewSharedArrayBuffer(data_.data(), data_.size(), is_wasm_memory);
}
{
Context::Scope scope(deserialization_context());
output_buffer_ =
NewSharedArrayBuffer(data_.data(), data_.size(), is_wasm_memory);
}
}
const Local<SharedArrayBuffer>& input_buffer() { return input_buffer_; }
const Local<SharedArrayBuffer>& output_buffer() { return output_buffer_; }
Local<SharedArrayBuffer> NewSharedArrayBuffer(void* data, size_t byte_length,
bool is_wasm_memory) {
#if V8_ENABLE_WEBASSEMBLY
if (is_wasm_memory) {
// TODO(titzer): there is no way to create Wasm memory backing stores
// through the API, or to create a shared array buffer whose backing
// store is wasm memory, so use the internal API.
DCHECK_EQ(0, byte_length % i::wasm::kWasmPageSize);
auto pages = byte_length / i::wasm::kWasmPageSize;
auto i_isolate = reinterpret_cast<i::Isolate*>(isolate());
auto backing_store = i::BackingStore::AllocateWasmMemory(
i_isolate, pages, pages, i::SharedFlag::kShared);
memcpy(backing_store->buffer_start(), data, byte_length);
i::Handle<i::JSArrayBuffer> buffer =
i_isolate->factory()->NewJSSharedArrayBuffer(
std::move(backing_store));
return Utils::ToLocalShared(buffer);
}
#endif // V8_ENABLE_WEBASSEMBLY
CHECK(!is_wasm_memory);
std::unique_ptr<v8::BackingStore> backing_store =
SharedArrayBuffer::NewBackingStore(
data, byte_length,
[](void*, size_t, void*) {
// Leak the buffer as it has the
// lifetime of the test.
},
nullptr);
return SharedArrayBuffer::New(isolate(), std::move(backing_store));
}
static void SetUpTestCase() {
flag_was_enabled_ = i::FLAG_harmony_sharedarraybuffer;
i::FLAG_harmony_sharedarraybuffer = true;
ValueSerializerTest::SetUpTestCase();
}
static void TearDownTestCase() {
ValueSerializerTest::TearDownTestCase();
i::FLAG_harmony_sharedarraybuffer = flag_was_enabled_;
flag_was_enabled_ = false;
}
protected:
// GMock doesn't use the "override" keyword.
#if __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winconsistent-missing-override"
#endif
class SerializerDelegate : public ValueSerializer::Delegate {
public:
explicit SerializerDelegate(
ValueSerializerTestWithSharedArrayBufferClone* test)
: test_(test) {}
MOCK_METHOD(Maybe<uint32_t>, GetSharedArrayBufferId,
(Isolate*, Local<SharedArrayBuffer> shared_array_buffer),
(override));
MOCK_METHOD(MaybeLocal<SharedArrayBuffer>, GetSharedArrayBufferFromId,
(Isolate*, uint32_t id));
void ThrowDataCloneError(Local<String> message) override {
test_->isolate()->ThrowException(Exception::Error(message));
}
private:
ValueSerializerTestWithSharedArrayBufferClone* test_;
};
class DeserializerDelegate : public ValueDeserializer::Delegate {
public:
explicit DeserializerDelegate(
ValueSerializerTestWithSharedArrayBufferClone* test) {}
MOCK_METHOD(MaybeLocal<SharedArrayBuffer>, GetSharedArrayBufferFromId,
(Isolate*, uint32_t id), (override));
};
#if __clang__
#pragma clang diagnostic pop
#endif
ValueSerializer::Delegate* GetSerializerDelegate() override {
return &serializer_delegate_;
}
ValueDeserializer::Delegate* GetDeserializerDelegate() override {
return &deserializer_delegate_;
}
SerializerDelegate serializer_delegate_;
DeserializerDelegate deserializer_delegate_;
private:
static bool flag_was_enabled_;
std::vector<uint8_t> data_;
Local<SharedArrayBuffer> input_buffer_;
Local<SharedArrayBuffer> output_buffer_;
};
bool ValueSerializerTestWithSharedArrayBufferClone::flag_was_enabled_ = false;
TEST_F(ValueSerializerTestWithSharedArrayBufferClone,
RoundTripSharedArrayBufferClone) {
InitializeData({0x00, 0x01, 0x80, 0xFF}, false);
EXPECT_CALL(serializer_delegate_,
GetSharedArrayBufferId(isolate(), input_buffer()))
.WillRepeatedly(Return(Just(0U)));
EXPECT_CALL(deserializer_delegate_, GetSharedArrayBufferFromId(isolate(), 0U))
.WillRepeatedly(Return(output_buffer()));
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'");
}
#if V8_ENABLE_WEBASSEMBLY
TEST_F(ValueSerializerTestWithSharedArrayBufferClone,
RoundTripWebAssemblyMemory) {
bool flag_was_enabled = i::FLAG_experimental_wasm_threads;
i::FLAG_experimental_wasm_threads = true;
std::vector<uint8_t> data = {0x00, 0x01, 0x80, 0xFF};
data.resize(65536);
InitializeData(data, true);
EXPECT_CALL(serializer_delegate_,
GetSharedArrayBufferId(isolate(), input_buffer()))
.WillRepeatedly(Return(Just(0U)));
EXPECT_CALL(deserializer_delegate_, GetSharedArrayBufferFromId(isolate(), 0U))
.WillRepeatedly(Return(output_buffer()));
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;
}
#endif // V8_ENABLE_WEBASSEMBLY
TEST_F(ValueSerializerTest, UnsupportedHostObject) {
InvalidEncodeTest("new ExampleHostObject()");
InvalidEncodeTest("({ a: new ExampleHostObject() })");
}
class ValueSerializerTestWithHostObject : public ValueSerializerTest {
protected:
ValueSerializerTestWithHostObject() : serializer_delegate_(this) {}
static const uint8_t kExampleHostObjectTag;
void WriteExampleHostObjectTag() {
serializer_->WriteRawBytes(&kExampleHostObjectTag, 1);
}
bool ReadExampleHostObjectTag() {
const void* tag;
return deserializer_->ReadRawBytes(1, &tag) &&
*reinterpret_cast<const uint8_t*>(tag) == kExampleHostObjectTag;
}
// GMock doesn't use the "override" keyword.
#if __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winconsistent-missing-override"
#endif
class SerializerDelegate : public ValueSerializer::Delegate {
public:
explicit SerializerDelegate(ValueSerializerTestWithHostObject* test)
: test_(test) {}
MOCK_METHOD(Maybe<bool>, WriteHostObject, (Isolate*, Local<Object> object),
(override));
void ThrowDataCloneError(Local<String> message) override {
test_->isolate()->ThrowException(Exception::Error(message));
}
private:
ValueSerializerTestWithHostObject* test_;
};
class DeserializerDelegate : public ValueDeserializer::Delegate {
public:
MOCK_METHOD(MaybeLocal<Object>, ReadHostObject, (Isolate*), (override));
};
#if __clang__
#pragma clang diagnostic pop
#endif
ValueSerializer::Delegate* GetSerializerDelegate() override {
return &serializer_delegate_;
}
void BeforeEncode(ValueSerializer* serializer) override {
serializer_ = serializer;
}
ValueDeserializer::Delegate* GetDeserializerDelegate() override {
return &deserializer_delegate_;
}
void BeforeDecode(ValueDeserializer* deserializer) override {
deserializer_ = deserializer;
}
SerializerDelegate serializer_delegate_;
DeserializerDelegate deserializer_delegate_;
ValueSerializer* serializer_;
ValueDeserializer* deserializer_;
friend class SerializerDelegate;
friend class DeserializerDelegate;
};
// This is a tag that is used in V8. Using this ensures that we have separate
// tag namespaces.
const uint8_t ValueSerializerTestWithHostObject::kExampleHostObjectTag = 'T';
TEST_F(ValueSerializerTestWithHostObject, RoundTripUint32) {
// The host can serialize data as uint32_t.
EXPECT_CALL(serializer_delegate_, WriteHostObject(isolate(), _))
.WillRepeatedly(Invoke([this](Isolate*, Local<Object> object) {
uint32_t value = 0;
EXPECT_TRUE(object->GetInternalField(0)
->Uint32Value(serialization_context())
.To(&value));
WriteExampleHostObjectTag();
serializer_->WriteUint32(value);
return Just(true);
}));
EXPECT_CALL(deserializer_delegate_, ReadHostObject(isolate()))
.WillRepeatedly(Invoke([this](Isolate*) {
EXPECT_TRUE(ReadExampleHostObjectTag());
uint32_t value = 0;
EXPECT_TRUE(deserializer_->ReadUint32(&value));
Local<Value> argv[] = {Integer::NewFromUnsigned(isolate(), value)};
return NewHostObject(deserialization_context(), arraysize(argv), argv);
}));
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) {
// The host can serialize data as uint64_t.
EXPECT_CALL(serializer_delegate_, WriteHostObject(isolate(), _))
.WillRepeatedly(Invoke([this](Isolate*, Local<Object> object) {
uint32_t value = 0, value2 = 0;
EXPECT_TRUE(object->GetInternalField(0)
->Uint32Value(serialization_context())
.To(&value));
EXPECT_TRUE(object->GetInternalField(1)
->Uint32Value(serialization_context())
.To(&value2));
WriteExampleHostObjectTag();
serializer_->WriteUint64((static_cast<uint64_t>(value) << 32) | value2);
return Just(true);
}));
EXPECT_CALL(deserializer_delegate_, ReadHostObject(isolate()))
.WillRepeatedly(Invoke([this](Isolate*) {
EXPECT_TRUE(ReadExampleHostObjectTag());
uint64_t value_packed;
EXPECT_TRUE(deserializer_->ReadUint64(&value_packed));
Local<Value> argv[] = {
Integer::NewFromUnsigned(isolate(),
static_cast<uint32_t>(value_packed >> 32)),
Integer::NewFromUnsigned(isolate(),
static_cast<uint32_t>(value_packed))};
return NewHostObject(deserialization_context(), arraysize(argv), argv);
}));
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) {
// The host can serialize data as double.
EXPECT_CALL(serializer_delegate_, WriteHostObject(isolate(), _))
.WillRepeatedly(Invoke([this](Isolate*, Local<Object> object) {
double value = 0;
EXPECT_TRUE(object->GetInternalField(0)
->NumberValue(serialization_context())
.To(&value));
WriteExampleHostObjectTag();
serializer_->WriteDouble(value);
return Just(true);
}));
EXPECT_CALL(deserializer_delegate_, ReadHostObject(isolate()))
.WillRepeatedly(Invoke([this](Isolate*) {
EXPECT_TRUE(ReadExampleHostObjectTag());
double value = 0;
EXPECT_TRUE(deserializer_->ReadDouble(&value));
Local<Value> argv[] = {Number::New(isolate(), value)};
return NewHostObject(deserialization_context(), arraysize(argv), argv);
}));
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) {
// The host can serialize arbitrary raw bytes.
const struct {
uint64_t u64;
uint32_t u32;
char str[12];
} sample_data = {0x1234567812345678, 0x87654321, "Hello world"};
EXPECT_CALL(serializer_delegate_, WriteHostObject(isolate(), _))
.WillRepeatedly(
Invoke([this, &sample_data](Isolate*, Local<Object> object) {
WriteExampleHostObjectTag();
serializer_->WriteRawBytes(&sample_data, sizeof(sample_data));
return Just(true);
}));
EXPECT_CALL(deserializer_delegate_, ReadHostObject(isolate()))
.WillRepeatedly(Invoke([this, &sample_data](Isolate*) {
EXPECT_TRUE(ReadExampleHostObjectTag());
const void* copied_data = nullptr;
EXPECT_TRUE(
deserializer_->ReadRawBytes(sizeof(sample_data), &copied_data));
if (copied_data) {
EXPECT_EQ(0, memcmp(&sample_data, copied_data, sizeof(sample_data)));
}
return NewHostObject(deserialization_context(), 0, nullptr);
}));
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) {
// If the same object exists in two places, the delegate should be invoked
// only once, and the objects should be the same (by reference equality) on
// the other side.
EXPECT_CALL(serializer_delegate_, WriteHostObject(isolate(), _))
.WillOnce(Invoke([this](Isolate*, Local<Object> object) {
WriteExampleHostObjectTag();
return Just(true);
}));
EXPECT_CALL(deserializer_delegate_, ReadHostObject(isolate()))
.WillOnce(Invoke([this](Isolate*) {
EXPECT_TRUE(ReadExampleHostObjectTag());
return NewHostObject(deserialization_context(), 0, nullptr);
}));
RoundTripTest("({ a: new ExampleHostObject(), get b() { return this.a; }})");
ExpectScriptTrue("result.a instanceof ExampleHostObject");
ExpectScriptTrue("result.a === result.b");
}
TEST_F(ValueSerializerTestWithHostObject, DecodeSimpleHostObject) {
EXPECT_CALL(deserializer_delegate_, ReadHostObject(isolate()))
.WillRepeatedly(Invoke([this](Isolate*) {
EXPECT_TRUE(ReadExampleHostObjectTag());
return NewHostObject(deserialization_context(), 0, nullptr);
}));
DecodeTest({0xFF, 0x0D, 0x5C, kExampleHostObjectTag});
ExpectScriptTrue(
"Object.getPrototypeOf(result) === ExampleHostObject.prototype");
}
class ValueSerializerTestWithHostArrayBufferView
: public ValueSerializerTestWithHostObject {
protected:
void BeforeEncode(ValueSerializer* serializer) override {
ValueSerializerTestWithHostObject::BeforeEncode(serializer);
serializer_->SetTreatArrayBufferViewsAsHostObjects(true);
}
};
TEST_F(ValueSerializerTestWithHostArrayBufferView, RoundTripUint8ArrayInput) {
EXPECT_CALL(serializer_delegate_, WriteHostObject(isolate(), _))
.WillOnce(Invoke([this](Isolate*, Local<Object> object) {
EXPECT_TRUE(object->IsUint8Array());
WriteExampleHostObjectTag();
return Just(true);
}));
EXPECT_CALL(deserializer_delegate_, ReadHostObject(isolate()))
.WillOnce(Invoke([this](Isolate*) {
EXPECT_TRUE(ReadExampleHostObjectTag());
return NewDummyUint8Array();
}));
RoundTripTest(
"({ 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");
}
#if V8_ENABLE_WEBASSEMBLY
// It's expected that WebAssembly has more exhaustive tests elsewhere; this
// mostly checks that the logic to embed it in structured clone serialization
// works correctly.
// A simple module which exports an "increment" function.
// Copied from test/mjsunit/wasm/incrementer.wasm.
constexpr uint8_t kIncrementerWasm[] = {
0, 97, 115, 109, 1, 0, 0, 0, 1, 6, 1, 96, 1, 127, 1, 127,
3, 2, 1, 0, 7, 13, 1, 9, 105, 110, 99, 114, 101, 109, 101, 110,
116, 0, 0, 10, 9, 1, 7, 0, 32, 0, 65, 1, 106, 11,
};
class ValueSerializerTestWithWasm : public ValueSerializerTest {
public:
static const char* kUnsupportedSerialization;
ValueSerializerTestWithWasm()
: serialize_delegate_(&transfer_modules_),
deserialize_delegate_(&transfer_modules_) {}
void Reset() {
current_serializer_delegate_ = nullptr;
transfer_modules_.clear();
}
void EnableTransferSerialization() {
current_serializer_delegate_ = &serialize_delegate_;
}
void EnableTransferDeserialization() {
current_deserializer_delegate_ = &deserialize_delegate_;
}
void EnableThrowingSerializer() {
current_serializer_delegate_ = &throwing_serializer_;
}
void EnableDefaultDeserializer() {
current_deserializer_delegate_ = &default_deserializer_;
}
protected:
static void SetUpTestCase() {
g_saved_flag = i::FLAG_expose_wasm;
i::FLAG_expose_wasm = true;
ValueSerializerTest::SetUpTestCase();
}
static void TearDownTestCase() {
ValueSerializerTest::TearDownTestCase();
i::FLAG_expose_wasm = g_saved_flag;
g_saved_flag = false;
}
class ThrowingSerializer : public ValueSerializer::Delegate {
public:
Maybe<uint32_t> GetWasmModuleTransferId(
Isolate* isolate, Local<WasmModuleObject> module) override {
isolate->ThrowException(Exception::Error(
String::NewFromOneByte(isolate, reinterpret_cast<const uint8_t*>(
kUnsupportedSerialization))
.ToLocalChecked()));
return Nothing<uint32_t>();
}
void ThrowDataCloneError(Local<String> message) override { UNREACHABLE(); }
};
class SerializeToTransfer : public ValueSerializer::Delegate {
public:
explicit SerializeToTransfer(std::vector<CompiledWasmModule>* modules)
: modules_(modules) {}
Maybe<uint32_t> GetWasmModuleTransferId(
Isolate* isolate, Local<WasmModuleObject> module) override {
modules_->push_back(module->GetCompiledModule());
return Just(static_cast<uint32_t>(modules_->size()) - 1);
}
void ThrowDataCloneError(Local<String> message) override { UNREACHABLE(); }
private:
std::vector<CompiledWasmModule>* modules_;
};
class DeserializeFromTransfer : public ValueDeserializer::Delegate {
public:
explicit DeserializeFromTransfer(std::vector<CompiledWasmModule>* modules)
: modules_(modules) {}
MaybeLocal<WasmModuleObject> GetWasmModuleFromId(Isolate* isolate,
uint32_t id) override {
return WasmModuleObject::FromCompiledModule(isolate, modules_->at(id));
}
private:
std::vector<CompiledWasmModule>* modules_;
};
ValueSerializer::Delegate* GetSerializerDelegate() override {
return current_serializer_delegate_;
}
ValueDeserializer::Delegate* GetDeserializerDelegate() override {
return current_deserializer_delegate_;
}
Local<WasmModuleObject> MakeWasm() {
Context::Scope scope(serialization_context());
i::wasm::ErrorThrower thrower(i_isolate(), "MakeWasm");
auto enabled_features = i::wasm::WasmFeatures::FromIsolate(i_isolate());
i::MaybeHandle<i::JSObject> compiled =
i_isolate()->wasm_engine()->SyncCompile(
i_isolate(), enabled_features, &thrower,
i::wasm::ModuleWireBytes(i::ArrayVector(kIncrementerWasm)));
CHECK(!thrower.error());
return Local<WasmModuleObject>::Cast(
Utils::ToLocal(compiled.ToHandleChecked()));
}
void ExpectPass() {
Local<Value> value = RoundTripTest(MakeWasm());
Context::Scope scope(deserialization_context());
ASSERT_TRUE(value->IsWasmModuleObject());
ExpectScriptTrue(
"new WebAssembly.Instance(result).exports.increment(8) === 9");
}
void ExpectFail() {
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()
->CreateDataProperty(serialization_context(),
StringFromUtf8("wasm_module"), wasm_module)
.FromMaybe(false);
Local<Script> script =
Script::Compile(
serialization_context(),
StringFromUtf8("({mod1: wasm_module, num: 2, mod2: wasm_module})"))
.ToLocalChecked();
return script->Run(serialization_context()).ToLocalChecked();
}
void VerifyComplexObject(Local<Value> value) {
ASSERT_TRUE(value->IsObject());
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()
->Global()
->CreateDataProperty(serialization_context(),
StringFromUtf8("wasm_module1"), wasm_module1)
.FromMaybe(false);
serialization_context()
->Global()
->CreateDataProperty(serialization_context(),
StringFromUtf8("wasm_module2"), wasm_module2)
.FromMaybe(false);
Local<Script> script =
Script::Compile(
serialization_context(),
StringFromUtf8(
"({mod1: wasm_module1, num: 2, mod2: wasm_module2})"))
.ToLocalChecked();
return script->Run(serialization_context()).ToLocalChecked();
}
private:
static bool g_saved_flag;
std::vector<CompiledWasmModule> transfer_modules_;
SerializeToTransfer serialize_delegate_;
DeserializeFromTransfer deserialize_delegate_;
ValueSerializer::Delegate* current_serializer_delegate_ = nullptr;
ValueDeserializer::Delegate* current_deserializer_delegate_ = nullptr;
ThrowingSerializer throwing_serializer_;
ValueDeserializer::Delegate default_deserializer_;
};
bool ValueSerializerTestWithWasm::g_saved_flag = false;
const char* ValueSerializerTestWithWasm::kUnsupportedSerialization =
"Wasm Serialization Not Supported";
// The default implementation of the serialization
// delegate throws when trying to serialize wasm. The
// embedder must decide serialization policy.
TEST_F(ValueSerializerTestWithWasm, DefaultSerializationDelegate) {
EnableThrowingSerializer();
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(isolate(),
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();
ExpectFail();
}
// We only want to allow deserialization through
// transferred modules - which requres both serializer
// and deserializer to understand that - or through
// explicitly allowing inlined data, which requires
// deserializer opt-in (we default the serializer to
// inlined data because we don't trust that data on the
// receiving end anyway).
TEST_F(ValueSerializerTestWithWasm, RoundtripWasmTransfer) {
EnableTransferSerialization();
EnableTransferDeserialization();
ExpectPass();
}
TEST_F(ValueSerializerTestWithWasm, CannotTransferWasmWhenExpectingInline) {
EnableTransferSerialization();
ExpectFail();
}
TEST_F(ValueSerializerTestWithWasm, ComplexObjectDuplicateTransfer) {
EnableTransferSerialization();
EnableTransferDeserialization();
Local<Value> value = RoundTripTest(GetComplexObjectWithDuplicate());
VerifyComplexObject(value);
ExpectScriptTrue("result.mod1 === result.mod2");
}
TEST_F(ValueSerializerTestWithWasm, ComplexObjectWithManyTransfer) {
EnableTransferSerialization();
EnableTransferDeserialization();
Local<Value> value = RoundTripTest(GetComplexObjectWithMany());
VerifyComplexObject(value);
ExpectScriptTrue("result.mod1 != result.mod2");
}
#endif // V8_ENABLE_WEBASSEMBLY
class ValueSerializerTestWithLimitedMemory : public ValueSerializerTest {
protected:
// GMock doesn't use the "override" keyword.
#if __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winconsistent-missing-override"
#endif
class SerializerDelegate : public ValueSerializer::Delegate {
public:
explicit SerializerDelegate(ValueSerializerTestWithLimitedMemory* test)
: test_(test) {}
~SerializerDelegate() { EXPECT_EQ(nullptr, last_buffer_); }
void SetMemoryLimit(size_t limit) { memory_limit_ = limit; }
void* ReallocateBufferMemory(void* old_buffer, size_t size,
size_t* actual_size) override {
EXPECT_EQ(old_buffer, last_buffer_);
if (size > memory_limit_) return nullptr;
*actual_size = size;
last_buffer_ = realloc(old_buffer, size);
return last_buffer_;
}
void FreeBufferMemory(void* buffer) override {
EXPECT_EQ(buffer, last_buffer_);
last_buffer_ = nullptr;
free(buffer);
}
void ThrowDataCloneError(Local<String> message) override {
test_->isolate()->ThrowException(Exception::Error(message));
}
MOCK_METHOD(Maybe<bool>, WriteHostObject, (Isolate*, Local<Object> object),
(override));
private:
ValueSerializerTestWithLimitedMemory* test_;
void* last_buffer_ = nullptr;
size_t memory_limit_ = 0;
};
#if __clang__
#pragma clang diagnostic pop
#endif
ValueSerializer::Delegate* GetSerializerDelegate() override {
return &serializer_delegate_;
}
void BeforeEncode(ValueSerializer* serializer) override {
serializer_ = serializer;
}
SerializerDelegate serializer_delegate_{this};
ValueSerializer* serializer_ = nullptr;
};
TEST_F(ValueSerializerTestWithLimitedMemory, FailIfNoMemoryInWriteHostObject) {
EXPECT_CALL(serializer_delegate_, WriteHostObject(isolate(), _))
.WillRepeatedly(Invoke([this](Isolate*, Local<Object>) {
static const char kDummyData[1024] = {};
serializer_->WriteRawBytes(&kDummyData, sizeof(kDummyData));
return Just(true);
}));
// If there is enough memory, things work.
serializer_delegate_.SetMemoryLimit(2048);
EncodeTest("new ExampleHostObject()");
// If not, we get a graceful failure, rather than silent misbehavior.
serializer_delegate_.SetMemoryLimit(1024);
InvalidEncodeTest("new ExampleHostObject()");
// And we definitely don't continue to serialize other things.
serializer_delegate_.SetMemoryLimit(1024);
EvaluateScriptForInput("gotA = false");
InvalidEncodeTest("[new ExampleHostObject, {get a() { gotA = true; }}]");
EXPECT_TRUE(EvaluateScriptForInput("gotA")->IsFalse());
}
// We only have basic tests and tests for .stack here, because we have more
// comprehensive tests as web platform tests.
TEST_F(ValueSerializerTest, RoundTripError) {
Local<Value> value = RoundTripTest("Error('hello')");
ASSERT_TRUE(value->IsObject());
Local<Object> error = value.As<Object>();
Local<Value> name;
Local<Value> message;
{
Context::Scope scope(deserialization_context());
EXPECT_EQ(error->GetPrototype(), Exception::Error(String::Empty(isolate()))
.As<Object>()
->GetPrototype());
}
ASSERT_TRUE(error->Get(deserialization_context(), StringFromUtf8("name"))
.ToLocal(&name));
ASSERT_TRUE(name->IsString());
EXPECT_EQ(Utf8Value(name), "Error");
ASSERT_TRUE(error->Get(deserialization_context(), StringFromUtf8("message"))
.ToLocal(&message));
ASSERT_TRUE(message->IsString());
EXPECT_EQ(Utf8Value(message), "hello");
}
TEST_F(ValueSerializerTest, DefaultErrorStack) {
Local<Value> value =
RoundTripTest("function hkalkcow() { return Error(); } hkalkcow();");
ASSERT_TRUE(value->IsObject());
Local<Object> error = value.As<Object>();
Local<Value> stack;
ASSERT_TRUE(error->Get(deserialization_context(), StringFromUtf8("stack"))
.ToLocal(&stack));
ASSERT_TRUE(stack->IsString());
EXPECT_NE(Utf8Value(stack).find("hkalkcow"), std::string::npos);
}
TEST_F(ValueSerializerTest, ModifiedErrorStack) {
Local<Value> value = RoundTripTest("let e = Error(); e.stack = 'hello'; e");
ASSERT_TRUE(value->IsObject());
Local<Object> error = value.As<Object>();
Local<Value> stack;
ASSERT_TRUE(error->Get(deserialization_context(), StringFromUtf8("stack"))
.ToLocal(&stack));
ASSERT_TRUE(stack->IsString());
EXPECT_EQ(Utf8Value(stack), "hello");
}
TEST_F(ValueSerializerTest, NonStringErrorStack) {
Local<Value> value = RoundTripTest("let e = Error(); e.stack = 17; e");
ASSERT_TRUE(value->IsObject());
Local<Object> error = value.As<Object>();
Local<Value> stack;
ASSERT_TRUE(error->Get(deserialization_context(), StringFromUtf8("stack"))
.ToLocal(&stack));
EXPECT_TRUE(stack->IsUndefined());
}
} // namespace
} // namespace v8
Reference in New Issue View Git Blame Copy Permalink