Add external byte array API and finalize external strings and byte arrays.

runtime/vm/object_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
@@ skipping 1726 matching lines @@
 
   EXPECT_EQ(0, Array::Handle(Array::Empty()).Length());
 }
 
 
 TEST_CASE(ExternalByteArray) {
   uint8_t data[] = { 253, 254, 255, 0, 1, 2, 3, 4 };
   intptr_t data_length = ARRAY_SIZE(data);
 
   const ExternalByteArray& array1 =
-      ExternalByteArray::Handle(ExternalByteArray::New(data, data_length));
+      ExternalByteArray::Handle(ExternalByteArray::New(data,
+                                                       data_length,
+                                                       NULL,
+                                                       NULL));
   EXPECT(!array1.IsNull());
   EXPECT_EQ(data_length, array1.Length());
   EXPECT_EQ(-3, array1.At<int8_t>(0));
   EXPECT_EQ(253, array1.At<uint8_t>(0));
   EXPECT_EQ(-2, array1.At<int8_t>(1));
   EXPECT_EQ(254, array1.At<uint8_t>(1));
   EXPECT_EQ(-1, array1.At<int8_t>(2));
   EXPECT_EQ(255, array1.At<uint8_t>(2));
   EXPECT_EQ(0, array1.At<int8_t>(3));
   EXPECT_EQ(0, array1.At<uint8_t>(3));
   EXPECT_EQ(1, array1.At<int8_t>(4));
   EXPECT_EQ(1, array1.At<uint8_t>(4));
   EXPECT_EQ(2, array1.At<int8_t>(5));
   EXPECT_EQ(2, array1.At<uint8_t>(5));
 
   const ExternalByteArray& array2 =
-      ExternalByteArray::Handle(ExternalByteArray::New(data, data_length));
+      ExternalByteArray::Handle(ExternalByteArray::New(data,
+                                                       data_length,
+                                                       NULL,
+                                                       NULL));
   EXPECT(!array1.IsNull());
   EXPECT_EQ(data_length, array2.Length());
   for (intptr_t i = 0 ; i < array1.Length(); ++i) {
     EXPECT_EQ(array1.At<uint8_t>(i), array2.At<uint8_t>(i));
   }
 
   array1.SetAt<uint8_t>(0, 123);
   array2.SetAt<int8_t>(2, -123);
   for (intptr_t i = 0 ; i < array1.Length(); ++i) {
     EXPECT_EQ(array1.At<uint8_t>(i), array2.At<uint8_t>(i));
   }
 }
 
 
 TEST_CASE(ExternalByteArrayAlignedAccess) {
   intptr_t length = 16;
   uint8_t* data = new uint8_t[length];
 
   const ExternalByteArray& array1 =
-      ExternalByteArray::Handle(ExternalByteArray::New(data, length));
+      ExternalByteArray::Handle(ExternalByteArray::New(data,
+                                                       length,
+                                                       NULL,
+                                                       NULL));
   EXPECT(!array1.IsNull());
   EXPECT_EQ(length, array1.Length());
 
   const ExternalByteArray& array2 =
-      ExternalByteArray::Handle(ExternalByteArray::New(data, length));
+      ExternalByteArray::Handle(ExternalByteArray::New(data,
+                                                       length,
+                                                       NULL,
+                                                       NULL));
   EXPECT(!array2.IsNull());
   EXPECT_EQ(length, array2.Length());
 
   memset(data, 0xAA, ARRAY_SIZE(data));
   array1.SetAt<float>(0, FLT_MIN);
   array1.SetAt<float>(4, FLT_MAX);
   EXPECT_EQ(FLT_MIN, array2.At<float>(0));
   EXPECT_EQ(FLT_MAX, array2.At<float>(4));
 
   memset(data, 0xAA, ARRAY_SIZE(data));
@@ skipping 16 matching lines @@
 
   delete[] data;
 }
 
 
 TEST_CASE(ExternalByteArrayUnlignedAccess) {
   intptr_t length = 24;
   uint8_t* data = new uint8_t[length];
 
   const ExternalByteArray& array1 =
-      ExternalByteArray::Handle(ExternalByteArray::New(data, length));
+      ExternalByteArray::Handle(ExternalByteArray::New(data,
+                                                       length,
+                                                       NULL,
+                                                       NULL));
   EXPECT(!array1.IsNull());
   EXPECT_EQ(length, array1.Length());
 
   const ExternalByteArray& array2 =
-      ExternalByteArray::Handle(ExternalByteArray::New(data, length));
+      ExternalByteArray::Handle(ExternalByteArray::New(data,
+                                                       length,
+                                                       NULL,
+                                                       NULL));
   EXPECT(!array2.IsNull());
   EXPECT_EQ(length, array2.Length());
 
   int float_misalign = 3;
   memset(data, 0xAA, ARRAY_SIZE(data));
   array1.SetUnalignedAt<float>(float_misalign, FLT_MIN);
   array1.SetUnalignedAt<float>(4 + float_misalign, FLT_MAX);
   EXPECT_EQ(FLT_MIN, array2.UnalignedAt<float>(float_misalign));
   EXPECT_EQ(FLT_MAX, array2.UnalignedAt<float>(4 + float_misalign));
 
@@ skipping 21 matching lines @@
 }
 
 
 TEST_CASE(ExternalByteArraySkewedUnalignedBaseAccess) {
   intptr_t length = 24;
   uint8_t* data = new uint8_t[length];
 
   int skew = 2;
 
   const ExternalByteArray& array1 =
-      ExternalByteArray::Handle(ExternalByteArray::New(data + 3, length));
+      ExternalByteArray::Handle(ExternalByteArray::New(data + 3,
+                                                       length,
+                                                       NULL,
+                                                       NULL));
   EXPECT(!array1.IsNull());
   EXPECT_EQ(length, array1.Length());
 
   const ExternalByteArray& array2 =
-      ExternalByteArray::Handle(ExternalByteArray::New(data + 1, length));
+      ExternalByteArray::Handle(ExternalByteArray::New(data + 1,
+                                                       length,
+                                                       NULL,
+                                                       NULL));
   EXPECT(!array2.IsNull());
   EXPECT_EQ(length, array2.Length());
 
   memset(data, 0xAA, ARRAY_SIZE(data));
   array1.SetUnalignedAt<float>(0, FLT_MIN);
   array1.SetUnalignedAt<float>(4, FLT_MAX);
   EXPECT_EQ(FLT_MIN, array2.UnalignedAt<float>(0 + skew));
   EXPECT_EQ(FLT_MAX, array2.UnalignedAt<float>(4 + skew));
 
   memset(data, 0xAA, ARRAY_SIZE(data));
@@ skipping 500 matching lines @@
     cls = iterator.GetNextClass();
     ASSERT((cls.raw() == ae66.raw()) || (cls.raw() == re44.raw()));
     count++;
   }
   ASSERT(count == 2);
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart