dart-lang/sdk
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

Fix some of the scalarlist tests to use TypedData VM classes.

Browse Source 
This is in preparation for removing dart:scalarlist support from the VM.
Review URL: https://codereview.chromium.org//12907010

git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@20532 260f80e4-7a28-3924-810f-c04153c831b5
This commit is contained in:
asiva@google.com
2013-03-26 18:46:44 +00:00
parent 85aa5f889e
commit 29cea159bf
5 changed files with 119 additions and 521 deletions
Download Patch File Download Diff File Expand all files Collapse all files
runtime/vm/benchmark_test.cc
+2 -2
View File
@@ -406,7 +406,7 @@ BENCHMARK(CoreSnapshotSize) {
"import 'dart:math';\n"
"import 'dart:isolate';\n"
"import 'dart:mirrors';\n"
"import 'dart:scalarlist';\n"
"import 'dart:typeddata';\n"
"\n";
// Start an Isolate, load a script and create a full snapshot.
@@ -432,7 +432,7 @@ BENCHMARK(StandaloneSnapshotSize) {
"import 'dart:math';\n"
"import 'dart:isolate';\n"
"import 'dart:mirrors';\n"
"import 'dart:scalarlist';\n"
"import 'dart:typeddata';\n"
"import 'dart:uri';\n"
"import 'dart:utf';\n"
"import 'dart:json';\n"
runtime/vm/object.cc
+8 -8
View File
@@ -575,7 +575,7 @@ void Object::CreateInternalMetaData() {
// Make unused space in an object whose type has been transformed safe
// for traversing during GC.
// The unused part of the transformed object is marked as an Int8Array
// The unused part of the transformed object is marked as an TypedDataInt8Array
// object.
void Object::MakeUnusedSpaceTraversable(const Object& obj,
intptr_t original_size,
@@ -587,16 +587,16 @@ void Object::MakeUnusedSpaceTraversable(const Object& obj,
intptr_t leftover_size = original_size - used_size;
uword addr = RawObject::ToAddr(obj.raw()) + used_size;
ASSERT(Int8Array::InstanceSize(0) == Object::InstanceSize());
// Update the leftover space as an Int8Array object.
RawInt8Array* raw =
reinterpret_cast<RawInt8Array*>(RawObject::FromAddr(addr));
ASSERT(TypedData::InstanceSize(0) == Object::InstanceSize());
// Update the leftover space as an TypedDataInt8Array object.
RawTypedData* raw =
reinterpret_cast<RawTypedData*>(RawObject::FromAddr(addr));
uword tags = 0;
tags = RawObject::SizeTag::update(leftover_size, tags);
tags = RawObject::ClassIdTag::update(kInt8ArrayCid, tags);
tags = RawObject::ClassIdTag::update(kTypedDataInt8ArrayCid, tags);
raw->ptr()->tags_ = tags;
intptr_t leftover_len = (leftover_size - Int8Array::InstanceSize(0));
ASSERT(Int8Array::InstanceSize(leftover_len) == leftover_size);
intptr_t leftover_len = (leftover_size - TypedData::InstanceSize(0));
ASSERT(TypedData::InstanceSize(leftover_len) == leftover_size);
raw->ptr()->length_ = Smi::New(leftover_len);
}
}
runtime/vm/object_test.cc
+73 -481
View File
@@ -1761,7 +1761,7 @@ TEST_CASE(GrowableObjectArray) {
// object is properly setup.
// 1. Should produce an array of length 2 and a left over int8 array.
Array& new_array = Array::Handle();
Int8Array& left_over_array = Int8Array::Handle();
TypedData& left_over_array = TypedData::Handle();
Object& obj = Object::Handle();
uword addr = 0;
intptr_t used_size = 0;
@@ -1782,7 +1782,7 @@ TEST_CASE(GrowableObjectArray) {
EXPECT_EQ(2, new_array.Length());
addr += used_size;
obj = RawObject::FromAddr(addr);
EXPECT(obj.IsInt8Array());
EXPECT(obj.IsTypedData());
left_over_array ^= obj.raw();
EXPECT_EQ((2 * kWordSize), left_over_array.Length());
@@ -1803,7 +1803,7 @@ TEST_CASE(GrowableObjectArray) {
EXPECT_EQ(3, new_array.Length());
addr += used_size;
obj = RawObject::FromAddr(addr);
EXPECT(obj.IsInt8Array());
EXPECT(obj.IsTypedData());
left_over_array ^= obj.raw();
EXPECT_EQ(0, left_over_array.Length());
@@ -1824,545 +1824,137 @@ TEST_CASE(GrowableObjectArray) {
EXPECT_EQ(1, new_array.Length());
addr += used_size;
obj = RawObject::FromAddr(addr);
EXPECT(obj.IsInt8Array());
EXPECT(obj.IsTypedData());
left_over_array ^= obj.raw();
EXPECT_EQ((6 * kWordSize), left_over_array.Length());
}
TEST_CASE(InternalByteArray) {
TEST_CASE(InternalTypedData) {
uint8_t data[] = { 253, 254, 255, 0, 1, 2, 3, 4 };
intptr_t data_length = ARRAY_SIZE(data);
const Int8Array& int8_array =
Int8Array::Handle(Int8Array::New(reinterpret_cast<int8_t*>(data),
data_length));
const TypedData& int8_array =
TypedData::Handle(TypedData::New(kTypedDataInt8ArrayCid, data_length));
EXPECT(!int8_array.IsNull());
EXPECT_EQ(data_length, int8_array.Length());
for (intptr_t i = 0; i < data_length; ++i) {
int8_array.SetInt8(i, data[i]);
}
EXPECT_EQ(-3, int8_array.At(0));
uint8_t at_0;
ByteArray::Copy(&at_0, int8_array, 0, sizeof(at_0));
EXPECT_EQ(253, at_0);
EXPECT_EQ(-3, int8_array.GetInt8(0));
EXPECT_EQ(253, int8_array.GetUint8(0));
EXPECT_EQ(-2, int8_array.At(1));
uint8_t at_1;
ByteArray::Copy(&at_1, int8_array, 1, sizeof(at_1));
EXPECT_EQ(254, at_1);
EXPECT_EQ(-2, int8_array.GetInt8(1));
EXPECT_EQ(254, int8_array.GetUint8(1));
EXPECT_EQ(-1, int8_array.At(2));
uint8_t at_2;
ByteArray::Copy(&at_2, int8_array, 2, sizeof(at_2));
EXPECT_EQ(255, at_2);
EXPECT_EQ(-1, int8_array.GetInt8(2));
EXPECT_EQ(255, int8_array.GetUint8(2));
EXPECT_EQ(0, int8_array.At(3));
uint8_t at_3;
ByteArray::Copy(&at_3, int8_array, 3, sizeof(at_3));
EXPECT_EQ(0, at_3);
EXPECT_EQ(0, int8_array.GetInt8(3));
EXPECT_EQ(0, int8_array.GetUint8(3));
EXPECT_EQ(1, int8_array.At(4));
uint8_t at_4;
ByteArray::Copy(&at_4, int8_array, 4, sizeof(at_4));
EXPECT_EQ(1, at_4);
EXPECT_EQ(1, int8_array.GetInt8(4));
EXPECT_EQ(1, int8_array.GetUint8(4));
EXPECT_EQ(2, int8_array.At(5));
uint8_t at_5;
ByteArray::Copy(&at_5, int8_array, 5, sizeof(at_5));
EXPECT_EQ(2, at_5);
EXPECT_EQ(2, int8_array.GetInt8(5));
EXPECT_EQ(2, int8_array.GetUint8(5));
EXPECT_EQ(3, int8_array.At(6));
uint8_t at_6;
ByteArray::Copy(&at_6, int8_array, 6, sizeof(at_6));
EXPECT_EQ(3, at_6);
EXPECT_EQ(3, int8_array.GetInt8(6));
EXPECT_EQ(3, int8_array.GetUint8(6));
EXPECT_EQ(4, int8_array.At(7));
uint8_t at_7;
ByteArray::Copy(&at_7, int8_array, 7, sizeof(at_7));
EXPECT_EQ(4, at_7);
EXPECT_EQ(4, int8_array.GetInt8(7));
EXPECT_EQ(4, int8_array.GetUint8(7));
const Int8Array& int8_array2 =
Int8Array::Handle(Int8Array::New(reinterpret_cast<int8_t*>(data),
data_length));
const TypedData& int8_array2 =
TypedData::Handle(TypedData::New(kTypedDataInt8ArrayCid, data_length));
EXPECT(!int8_array.IsNull());
EXPECT_EQ(data_length, int8_array.Length());
for (intptr_t i = 0; i < data_length; ++i) {
int8_array2.SetInt8(i, data[i]);
}
for (intptr_t i = 0; i < data_length; ++i) {
EXPECT_EQ(int8_array.At(i), int8_array2.At(i));
EXPECT_EQ(int8_array.GetInt8(i), int8_array2.GetInt8(i));
}
for (intptr_t i = 0; i < data_length; ++i) {
int8_array.SetAt(i, 123 + i);
int8_array.SetInt8(i, 123 + i);
}
for (intptr_t i = 0; i < data_length; ++i) {
EXPECT(int8_array.At(i) != int8_array2.At(i));
EXPECT(int8_array.GetInt8(i) != int8_array2.GetInt8(i));
}
}
TEST_CASE(ExternalByteArray) {
TEST_CASE(ExternalTypedData) {
uint8_t data[] = { 253, 254, 255, 0, 1, 2, 3, 4 };
intptr_t data_length = ARRAY_SIZE(data);
const ExternalInt8Array& int8_array =
ExternalInt8Array::Handle(
ExternalInt8Array::New(reinterpret_cast<int8_t*>(data),
const ExternalTypedData& int8_array =
ExternalTypedData::Handle(
ExternalTypedData::New(kExternalTypedDataInt8ArrayCid,
data,
data_length));
EXPECT(!int8_array.IsNull());
EXPECT_EQ(data_length, int8_array.Length());
const ExternalUint8Array& uint8_array =
ExternalUint8Array::Handle(
ExternalUint8Array::New(data, data_length));
const ExternalTypedData& uint8_array =
ExternalTypedData::Handle(
ExternalTypedData::New(kExternalTypedDataUint8ArrayCid,
data,
data_length));
EXPECT(!uint8_array.IsNull());
EXPECT_EQ(data_length, uint8_array.Length());
const ExternalUint8ClampedArray& uint8_clamped_array =
ExternalUint8ClampedArray::Handle(
ExternalUint8ClampedArray::New(data, data_length));
const ExternalTypedData& uint8_clamped_array =
ExternalTypedData::Handle(
ExternalTypedData::New(kExternalTypedDataUint8ClampedArrayCid,
data,
data_length));
EXPECT(!uint8_clamped_array.IsNull());
EXPECT_EQ(data_length, uint8_clamped_array.Length());
EXPECT_EQ(-3, int8_array.At(0));
EXPECT_EQ(253, uint8_array.At(0));
EXPECT_EQ(253, uint8_clamped_array.At(0));
EXPECT_EQ(-3, int8_array.GetInt8(0));
EXPECT_EQ(253, uint8_array.GetUint8(0));
EXPECT_EQ(253, uint8_clamped_array.GetUint8(0));
EXPECT_EQ(-2, int8_array.At(1));
EXPECT_EQ(254, uint8_array.At(1));
EXPECT_EQ(254, uint8_clamped_array.At(1));
EXPECT_EQ(-2, int8_array.GetInt8(1));
EXPECT_EQ(254, uint8_array.GetUint8(1));
EXPECT_EQ(254, uint8_clamped_array.GetUint8(1));
EXPECT_EQ(-1, int8_array.At(2));
EXPECT_EQ(255, uint8_array.At(2));
EXPECT_EQ(255, uint8_clamped_array.At(2));
EXPECT_EQ(-1, int8_array.GetInt8(2));
EXPECT_EQ(255, uint8_array.GetUint8(2));
EXPECT_EQ(255, uint8_clamped_array.GetUint8(2));
EXPECT_EQ(0, int8_array.At(3));
EXPECT_EQ(0, uint8_array.At(3));
EXPECT_EQ(0, uint8_clamped_array.At(3));
EXPECT_EQ(0, int8_array.GetInt8(3));
EXPECT_EQ(0, uint8_array.GetUint8(3));
EXPECT_EQ(0, uint8_clamped_array.GetUint8(3));
EXPECT_EQ(1, int8_array.At(4));
EXPECT_EQ(1, uint8_array.At(4));
EXPECT_EQ(1, uint8_clamped_array.At(4));
EXPECT_EQ(1, int8_array.GetInt8(4));
EXPECT_EQ(1, uint8_array.GetUint8(4));
EXPECT_EQ(1, uint8_clamped_array.GetUint8(4));
EXPECT_EQ(2, int8_array.At(5));
EXPECT_EQ(2, uint8_array.At(5));
EXPECT_EQ(2, uint8_clamped_array.At(5));
EXPECT_EQ(2, int8_array.GetInt8(5));
EXPECT_EQ(2, uint8_array.GetUint8(5));
EXPECT_EQ(2, uint8_clamped_array.GetUint8(5));
for (intptr_t i = 0 ; i < int8_array.Length(); ++i) {
uint8_t value = 0;
ByteArray::Copy(&value, int8_array, i, sizeof(value));
EXPECT_EQ(value, uint8_array.At(i));
EXPECT_EQ(int8_array.GetUint8(i), uint8_array.GetUint8(i));
}
int8_array.SetAt(2, -123);
uint8_array.SetAt(0, 123);
int8_array.SetInt8(2, -123);
uint8_array.SetUint8(0, 123);
for (intptr_t i = 0 ; i < int8_array.Length(); ++i) {
int8_t value = 0;
ByteArray::Copy(&value, uint8_array, i, sizeof(value));
EXPECT_EQ(int8_array.At(i), value);
EXPECT_EQ(int8_array.GetInt8(i), uint8_array.GetInt8(i));
}
uint8_clamped_array.SetAt(0, 123);
uint8_clamped_array.SetUint8(0, 123);
for (intptr_t i = 0 ; i < int8_array.Length(); ++i) {
int8_t value = 0;
ByteArray::Copy(&value, uint8_clamped_array, i, sizeof(value));
EXPECT_EQ(int8_array.At(i), value);
EXPECT_EQ(int8_array.GetUint8(i), uint8_clamped_array.GetUint8(i));
}
}
TEST_CASE(UInt8ByteArrayCopyInternal) {
const uint8_t b_0_1_2_3[] = { 0, 1, 2, 3 };
const uint8_t b_4_5_6_7[] = { 4, 5, 6, 7 };
const Uint8Array& internal =
Uint8Array::Handle(Uint8Array::New(b_0_1_2_3, ARRAY_SIZE(b_0_1_2_3)));
EXPECT(!internal.IsNull());
EXPECT_EQ(4, internal.Length());
EXPECT_EQ(0, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(2, internal.At(2));
EXPECT_EQ(3, internal.At(3));
// A zero length copy.
ByteArray::Copy(internal, 0, b_4_5_6_7, 0);
EXPECT_EQ(0, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(2, internal.At(2));
EXPECT_EQ(3, internal.At(3));
// Another zero length copy.
ByteArray::Copy(internal, 4, b_4_5_6_7, 0);
EXPECT_EQ(0, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(2, internal.At(2));
EXPECT_EQ(3, internal.At(3));
// A one element copy.
ByteArray::Copy(internal, 0, b_4_5_6_7, 1);
EXPECT_EQ(4, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(2, internal.At(2));
EXPECT_EQ(3, internal.At(3));
// A two element copy.
ByteArray::Copy(internal, 2, b_4_5_6_7, 2);
EXPECT_EQ(4, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(4, internal.At(2));
EXPECT_EQ(5, internal.At(3));
// A three element copy.
ByteArray::Copy(internal, 1, b_4_5_6_7, 3);
EXPECT_EQ(4, internal.At(0));
EXPECT_EQ(4, internal.At(1));
EXPECT_EQ(5, internal.At(2));
EXPECT_EQ(6, internal.At(3));
// A four element copy.
ByteArray::Copy(internal, 0, b_0_1_2_3, 4);
EXPECT_EQ(0, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(2, internal.At(2));
EXPECT_EQ(3, internal.At(3));
}
TEST_CASE(ClampedUInt8ByteArrayCopyInternal) {
const uint8_t b_0_1_2_3[] = { 0, 1, 2, 3 };
const uint8_t b_4_5_6_7[] = { 4, 5, 6, 7 };
const Uint8ClampedArray& internal =
Uint8ClampedArray::Handle(
Uint8ClampedArray::New(b_0_1_2_3, ARRAY_SIZE(b_0_1_2_3)));
EXPECT(!internal.IsNull());
EXPECT_EQ(4, internal.Length());
EXPECT_EQ(0, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(2, internal.At(2));
EXPECT_EQ(3, internal.At(3));
// A zero length copy.
ByteArray::Copy(internal, 0, b_4_5_6_7, 0);
EXPECT_EQ(0, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(2, internal.At(2));
EXPECT_EQ(3, internal.At(3));
// Another zero length copy.
ByteArray::Copy(internal, 4, b_4_5_6_7, 0);
EXPECT_EQ(0, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(2, internal.At(2));
EXPECT_EQ(3, internal.At(3));
// A one element copy.
ByteArray::Copy(internal, 0, b_4_5_6_7, 1);
EXPECT_EQ(4, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(2, internal.At(2));
EXPECT_EQ(3, internal.At(3));
// A two element copy.
ByteArray::Copy(internal, 2, b_4_5_6_7, 2);
EXPECT_EQ(4, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(4, internal.At(2));
EXPECT_EQ(5, internal.At(3));
// A three element copy.
ByteArray::Copy(internal, 1, b_4_5_6_7, 3);
EXPECT_EQ(4, internal.At(0));
EXPECT_EQ(4, internal.At(1));
EXPECT_EQ(5, internal.At(2));
EXPECT_EQ(6, internal.At(3));
// A four element copy.
ByteArray::Copy(internal, 0, b_0_1_2_3, 4);
EXPECT_EQ(0, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(2, internal.At(2));
EXPECT_EQ(3, internal.At(3));
}
TEST_CASE(Uint8ByteArrayCopyExternal) {
const uint8_t b_0_1_2_3[] = { 0, 1, 2, 3 };
const uint8_t b_4_5_6_7[] = { 4, 5, 6, 7 };
uint8_t data[] = { 0, 1, 2, 3 };
const ExternalUint8Array& external =
ExternalUint8Array::Handle(
ExternalUint8Array::New(data, ARRAY_SIZE(data)));
EXPECT(!external.IsNull());
EXPECT_EQ(4, external.Length());
EXPECT_EQ(0, external.At(0));
EXPECT_EQ(1, external.At(1));
EXPECT_EQ(2, external.At(2));
EXPECT_EQ(3, external.At(3));
// A zero length copy.
ByteArray::Copy(external, 0, b_4_5_6_7, 0);
EXPECT_EQ(0, external.At(0));
EXPECT_EQ(1, external.At(1));
EXPECT_EQ(2, external.At(2));
EXPECT_EQ(3, external.At(3));
// Another zero length copy.
ByteArray::Copy(external, 4, b_4_5_6_7, 0);
EXPECT_EQ(0, external.At(0));
EXPECT_EQ(1, external.At(1));
EXPECT_EQ(2, external.At(2));
EXPECT_EQ(3, external.At(3));
// A one element copy.
ByteArray::Copy(external, 0, b_4_5_6_7, 1);
EXPECT_EQ(4, external.At(0));
EXPECT_EQ(1, external.At(1));
EXPECT_EQ(2, external.At(2));
EXPECT_EQ(3, external.At(3));
// A two element copy.
ByteArray::Copy(external, 2, b_4_5_6_7, 2);
EXPECT_EQ(4, external.At(0));
EXPECT_EQ(1, external.At(1));
EXPECT_EQ(4, external.At(2));
EXPECT_EQ(5, external.At(3));
// A three element copy.
ByteArray::Copy(external, 1, b_4_5_6_7, 3);
EXPECT_EQ(4, external.At(0));
EXPECT_EQ(4, external.At(1));
EXPECT_EQ(5, external.At(2));
EXPECT_EQ(6, external.At(3));
// A four element copy.
ByteArray::Copy(external, 0, b_0_1_2_3, 4);
EXPECT_EQ(0, external.At(0));
EXPECT_EQ(1, external.At(1));
EXPECT_EQ(2, external.At(2));
EXPECT_EQ(3, external.At(3));
}
TEST_CASE(ClampedUint8ByteArrayCopyExternal) {
const uint8_t b_0_1_2_3[] = { 0, 1, 2, 3 };
const uint8_t b_4_5_6_7[] = { 4, 5, 6, 7 };
uint8_t data[] = { 0, 1, 2, 3 };
const ExternalUint8ClampedArray& external =
ExternalUint8ClampedArray::Handle(
ExternalUint8ClampedArray::New(data, ARRAY_SIZE(data)));
EXPECT(!external.IsNull());
EXPECT_EQ(4, external.Length());
EXPECT_EQ(0, external.At(0));
EXPECT_EQ(1, external.At(1));
EXPECT_EQ(2, external.At(2));
EXPECT_EQ(3, external.At(3));
// A zero length copy.
ByteArray::Copy(external, 0, b_4_5_6_7, 0);
EXPECT_EQ(0, external.At(0));
EXPECT_EQ(1, external.At(1));
EXPECT_EQ(2, external.At(2));
EXPECT_EQ(3, external.At(3));
// Another zero length copy.
ByteArray::Copy(external, 4, b_4_5_6_7, 0);
EXPECT_EQ(0, external.At(0));
EXPECT_EQ(1, external.At(1));
EXPECT_EQ(2, external.At(2));
EXPECT_EQ(3, external.At(3));
// A one element copy.
ByteArray::Copy(external, 0, b_4_5_6_7, 1);
EXPECT_EQ(4, external.At(0));
EXPECT_EQ(1, external.At(1));
EXPECT_EQ(2, external.At(2));
EXPECT_EQ(3, external.At(3));
// A two element copy.
ByteArray::Copy(external, 2, b_4_5_6_7, 2);
EXPECT_EQ(4, external.At(0));
EXPECT_EQ(1, external.At(1));
EXPECT_EQ(4, external.At(2));
EXPECT_EQ(5, external.At(3));
// A three element copy.
ByteArray::Copy(external, 1, b_4_5_6_7, 3);
EXPECT_EQ(4, external.At(0));
EXPECT_EQ(4, external.At(1));
EXPECT_EQ(5, external.At(2));
EXPECT_EQ(6, external.At(3));
// A four element copy.
ByteArray::Copy(external, 0, b_0_1_2_3, 4);
EXPECT_EQ(0, external.At(0));
EXPECT_EQ(1, external.At(1));
EXPECT_EQ(2, external.At(2));
EXPECT_EQ(3, external.At(3));
}
TEST_CASE(Uint8ByteArrayCopyInternalExternal) {
const uint8_t b_0_1_2_3[] = { 0, 1, 2, 3 };
uint8_t data[] = { 4, 5, 6, 7 };
const Uint8Array& internal =
Uint8Array::Handle(Uint8Array::New(b_0_1_2_3, ARRAY_SIZE(b_0_1_2_3)));
EXPECT(!internal.IsNull());
EXPECT_EQ(4, internal.Length());
EXPECT_EQ(0, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(2, internal.At(2));
EXPECT_EQ(3, internal.At(3));
const ExternalUint8Array& external =
ExternalUint8Array::Handle(
ExternalUint8Array::New(data, ARRAY_SIZE(data)));
EXPECT(!external.IsNull());
EXPECT_EQ(4, external.Length());
EXPECT_EQ(4, external.At(0));
EXPECT_EQ(5, external.At(1));
EXPECT_EQ(6, external.At(2));
EXPECT_EQ(7, external.At(3));
// A zero length copy.
ByteArray::Copy(internal, 0, external, 0, 0);
EXPECT_EQ(0, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(2, internal.At(2));
EXPECT_EQ(3, internal.At(3));
// A zero length copy, take 2.
ByteArray::Copy(internal, 4, external, 0, 0);
EXPECT_EQ(0, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(2, internal.At(2));
EXPECT_EQ(3, internal.At(3));
// A zero length copy, take 3.
ByteArray::Copy(internal, 0, external, 4, 0);
EXPECT_EQ(0, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(2, internal.At(2));
EXPECT_EQ(3, internal.At(3));
// A zero length copy, take 4.
ByteArray::Copy(internal, 4, external, 4, 0);
EXPECT_EQ(0, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(2, internal.At(2));
EXPECT_EQ(3, internal.At(3));
// A four element copy.
ByteArray::Copy(internal, 0, external, 0, 4);
EXPECT_EQ(4, internal.At(0));
EXPECT_EQ(5, internal.At(1));
EXPECT_EQ(6, internal.At(2));
EXPECT_EQ(7, internal.At(3));
EXPECT_EQ(4, external.At(0));
EXPECT_EQ(5, external.At(1));
EXPECT_EQ(6, external.At(2));
EXPECT_EQ(7, external.At(3));
// A four element copy, take 2.
ByteArray::Copy(external, 0, b_0_1_2_3, 4);
EXPECT_EQ(0, external.At(0));
EXPECT_EQ(1, external.At(1));
EXPECT_EQ(2, external.At(2));
EXPECT_EQ(3, external.At(3));
ByteArray::Copy(external, 0, internal, 0, 4);
EXPECT_EQ(4, internal.At(0));
EXPECT_EQ(5, internal.At(1));
EXPECT_EQ(6, internal.At(2));
EXPECT_EQ(7, internal.At(3));
EXPECT_EQ(4, external.At(0));
EXPECT_EQ(5, external.At(1));
EXPECT_EQ(6, external.At(2));
EXPECT_EQ(7, external.At(3));
}
TEST_CASE(ClampedUint8ByteArrayCopyInternalExternal) {
const uint8_t b_0_1_2_3[] = { 0, 1, 2, 3 };
uint8_t data[] = { 4, 5, 6, 7 };
const Uint8ClampedArray& internal =
Uint8ClampedArray::Handle(
Uint8ClampedArray::New(b_0_1_2_3, ARRAY_SIZE(b_0_1_2_3)));
EXPECT(!internal.IsNull());
EXPECT_EQ(4, internal.Length());
EXPECT_EQ(0, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(2, internal.At(2));
EXPECT_EQ(3, internal.At(3));
const ExternalUint8ClampedArray& external =
ExternalUint8ClampedArray::Handle(
ExternalUint8ClampedArray::New(data, ARRAY_SIZE(data)));
EXPECT(!external.IsNull());
EXPECT_EQ(4, external.Length());
EXPECT_EQ(4, external.At(0));
EXPECT_EQ(5, external.At(1));
EXPECT_EQ(6, external.At(2));
EXPECT_EQ(7, external.At(3));
// A zero length copy.
ByteArray::Copy(internal, 0, external, 0, 0);
EXPECT_EQ(0, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(2, internal.At(2));
EXPECT_EQ(3, internal.At(3));
// A zero length copy, take 2.
ByteArray::Copy(internal, 4, external, 0, 0);
EXPECT_EQ(0, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(2, internal.At(2));
EXPECT_EQ(3, internal.At(3));
// A zero length copy, take 3.
ByteArray::Copy(internal, 0, external, 4, 0);
EXPECT_EQ(0, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(2, internal.At(2));
EXPECT_EQ(3, internal.At(3));
// A zero length copy, take 4.
ByteArray::Copy(internal, 4, external, 4, 0);
EXPECT_EQ(0, internal.At(0));
EXPECT_EQ(1, internal.At(1));
EXPECT_EQ(2, internal.At(2));
EXPECT_EQ(3, internal.At(3));
// A four element copy.
ByteArray::Copy(internal, 0, external, 0, 4);
EXPECT_EQ(4, internal.At(0));
EXPECT_EQ(5, internal.At(1));
EXPECT_EQ(6, internal.At(2));
EXPECT_EQ(7, internal.At(3));
EXPECT_EQ(4, external.At(0));
EXPECT_EQ(5, external.At(1));
EXPECT_EQ(6, external.At(2));
EXPECT_EQ(7, external.At(3));
// A four element copy, take 2.
ByteArray::Copy(external, 0, b_0_1_2_3, 4);
EXPECT_EQ(0, external.At(0));
EXPECT_EQ(1, external.At(1));
EXPECT_EQ(2, external.At(2));
EXPECT_EQ(3, external.At(3));
ByteArray::Copy(external, 0, internal, 0, 4);
EXPECT_EQ(4, internal.At(0));
EXPECT_EQ(5, internal.At(1));
EXPECT_EQ(6, internal.At(2));
EXPECT_EQ(7, internal.At(3));
EXPECT_EQ(4, external.At(0));
EXPECT_EQ(5, external.At(1));
EXPECT_EQ(6, external.At(2));
EXPECT_EQ(7, external.At(3));
}
TEST_CASE(Script) {
const char* url_chars = "builtin:test-case";
const char* source_chars = "This will not compile.";
runtime/vm/raw_object.h
+2 -2
View File
@@ -1440,6 +1440,8 @@ class RawTypedData : public RawInstance {
// Variable length data follows here.
uint8_t data_[0];
friend class Object;
};
@@ -1471,8 +1473,6 @@ class RawInt8Array : public RawByteArray {
// Variable length data follows here.
int8_t data_[0];
friend class Object;
};
runtime/vm/snapshot_test.cc
+34 -28
View File
@@ -647,18 +647,21 @@ TEST_CASE(SerializeByteArray) {
uint8_t* buffer; \
MessageWriter writer(&buffer, &zone_allocator); \
const int kArrayLength = 127; \
darttype& array = darttype::Handle(darttype::New(kArrayLength)); \
TypedData& array = TypedData::Handle( \
TypedData::New(kTypedData##darttype##ArrayCid, kArrayLength)); \
intptr_t scale = array.ElementSizeInBytes(); \
for (int i = 0; i < kArrayLength; i++) { \
array.SetAt(i, i); \
array.Set##darttype((i * scale), i); \
} \
writer.WriteMessage(array); \
intptr_t buffer_len = writer.BytesWritten(); \
SnapshotReader reader(buffer, buffer_len, \
Snapshot::kMessage, Isolate::Current()); \
darttype& serialized_array = darttype::Handle(); \
TypedData& serialized_array = TypedData::Handle(); \
serialized_array ^= reader.ReadObject(); \
for (int i = 0; i < kArrayLength; i++) { \
EXPECT_EQ(static_cast<ctype>(i), serialized_array.At(i)); \
EXPECT_EQ(static_cast<ctype>(i), \
serialized_array.Get##darttype(i*scale)); \
} \
}
@@ -668,47 +671,50 @@ TEST_CASE(SerializeByteArray) {
StackZone zone(Isolate::Current()); \
ctype data[] = { 0, 11, 22, 33, 44, 55, 66, 77 }; \
intptr_t length = ARRAY_SIZE(data); \
External##darttype& array = External##darttype::Handle( \
External##darttype::New(data, length)); \
ExternalTypedData& array = ExternalTypedData::Handle( \
ExternalTypedData::New(kExternalTypedData##darttype##ArrayCid, \
reinterpret_cast<uint8_t*>(data), length)); \
intptr_t scale = array.ElementSizeInBytes(); \
uint8_t* buffer; \
MessageWriter writer(&buffer, &zone_allocator); \
writer.WriteMessage(array); \
intptr_t buffer_len = writer.BytesWritten(); \
SnapshotReader reader(buffer, buffer_len, \
Snapshot::kMessage, Isolate::Current()); \
darttype& serialized_array = darttype::Handle(); \
TypedData& serialized_array = TypedData::Handle(); \
serialized_array ^= reader.ReadObject(); \
for (int i = 0; i < length; i++) { \
EXPECT_EQ(static_cast<ctype>(data[i]), serialized_array.At(i)); \
EXPECT_EQ(static_cast<ctype>(data[i]), \
serialized_array.Get##darttype(i*scale)); \
} \
}
TEST_CASE(SerializeTypedArray) {
TEST_TYPED_ARRAY(Int8Array, int8_t);
TEST_TYPED_ARRAY(Uint8Array, uint8_t);
TEST_TYPED_ARRAY(Int16Array, int16_t);
TEST_TYPED_ARRAY(Uint16Array, uint16_t);
TEST_TYPED_ARRAY(Int32Array, int32_t);
TEST_TYPED_ARRAY(Uint32Array, uint32_t);
TEST_TYPED_ARRAY(Int64Array, int64_t);
TEST_TYPED_ARRAY(Uint64Array, uint64_t);
TEST_TYPED_ARRAY(Float32Array, float);
TEST_TYPED_ARRAY(Float64Array, double);
TEST_TYPED_ARRAY(Int8, int8_t);
TEST_TYPED_ARRAY(Uint8, uint8_t);
TEST_TYPED_ARRAY(Int16, int16_t);
TEST_TYPED_ARRAY(Uint16, uint16_t);
TEST_TYPED_ARRAY(Int32, int32_t);
TEST_TYPED_ARRAY(Uint32, uint32_t);
TEST_TYPED_ARRAY(Int64, int64_t);
TEST_TYPED_ARRAY(Uint64, uint64_t);
TEST_TYPED_ARRAY(Float32, float);
TEST_TYPED_ARRAY(Float64, double);
}
TEST_CASE(SerializeExternalTypedArray) {
TEST_EXTERNAL_TYPED_ARRAY(Int8Array, int8_t);
TEST_EXTERNAL_TYPED_ARRAY(Uint8Array, uint8_t);
TEST_EXTERNAL_TYPED_ARRAY(Int16Array, int16_t);
TEST_EXTERNAL_TYPED_ARRAY(Uint16Array, uint16_t);
TEST_EXTERNAL_TYPED_ARRAY(Int32Array, int32_t);
TEST_EXTERNAL_TYPED_ARRAY(Uint32Array, uint32_t);
TEST_EXTERNAL_TYPED_ARRAY(Int64Array, int64_t);
TEST_EXTERNAL_TYPED_ARRAY(Uint64Array, uint64_t);
TEST_EXTERNAL_TYPED_ARRAY(Float32Array, float);
TEST_EXTERNAL_TYPED_ARRAY(Float64Array, double);
TEST_EXTERNAL_TYPED_ARRAY(Int8, int8_t);
TEST_EXTERNAL_TYPED_ARRAY(Uint8, uint8_t);
TEST_EXTERNAL_TYPED_ARRAY(Int16, int16_t);
TEST_EXTERNAL_TYPED_ARRAY(Uint16, uint16_t);
TEST_EXTERNAL_TYPED_ARRAY(Int32, int32_t);
TEST_EXTERNAL_TYPED_ARRAY(Uint32, uint32_t);
TEST_EXTERNAL_TYPED_ARRAY(Int64, int64_t);
TEST_EXTERNAL_TYPED_ARRAY(Uint64, uint64_t);
TEST_EXTERNAL_TYPED_ARRAY(Float32, float);
TEST_EXTERNAL_TYPED_ARRAY(Float64, double);
}