Add an external array type to support typed arrays.

runtime/vm/object_test.cc

 // Copyright (c) 2011, 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 "vm/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 1574 matching lines @@
 
   other_array = Array::New(kArrayLen - 1);
   other_array.SetAt(0, array);
   other_array.SetAt(2, array);
   EXPECT(!array.Equals(other_array));
 
   EXPECT_EQ(0, Array::Handle(Array::Empty()).Length());
 }
 
 
+TEST_CASE(ByteBuffer) {
+  uint8_t data[] = { 253, 254, 255, 0, 1, 2, 3, 4 };
+  intptr_t data_length = ARRAY_SIZE(data);
+
+  const ByteBuffer& array1 =
+      ByteBuffer::Handle(ByteBuffer::New(data, data_length));
+  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 ByteBuffer& array2 =
+      ByteBuffer::Handle(ByteBuffer::New(data, data_length));
+  EXPECT(!array1.IsNull());
+  EXPECT_EQ(data_length, array2.Length());
+  EXPECT(array1.Equals(array2));
+  EXPECT(array2.Equals(array1));
+
+  array1.SetAt<uint8_t>(0, 123);
+  array2.SetAt<int8_t>(2, -123);
+  EXPECT(array1.Equals(array2));
+  EXPECT(array2.Equals(array1));
+}
+
+
+TEST_CASE(ByteBufferAlignedAccess) {
+  intptr_t length = 16;
+  uint8_t* data = new uint8_t[length];
+
+  const ByteBuffer& array1 =
+      ByteBuffer::Handle(ByteBuffer::New(data, length));
+  EXPECT(!array1.IsNull());
+  EXPECT_EQ(length, array1.Length());
+
+  const ByteBuffer& array2 =
+      ByteBuffer::Handle(ByteBuffer::New(data, length));
+  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));
+  array1.SetAt<float>(0, 0.0f);
+  EXPECT_EQ(0.0f, array2.At<float>(0));
+  array1.SetAt<float>(4, 1.0f);
+  EXPECT_EQ(1.0f, array2.At<float>(4));
+
+  memset(data, 0xAA, ARRAY_SIZE(data));
+  array1.SetAt<double>(0, DBL_MIN);
+  EXPECT_EQ(DBL_MIN, array2.At<double>(0));
+  array1.SetAt<double>(8, DBL_MAX);
+  EXPECT_EQ(DBL_MAX, array2.At<double>(8));
+
+  memset(data, 0xAA, ARRAY_SIZE(data));
+  array1.SetAt<double>(0, 0.0);
+  EXPECT_EQ(0.0, array2.At<double>(0));
+  array1.SetAt<double>(8, 1.0);
+  EXPECT_EQ(1.0, array2.At<double>(8));
+
+  delete[] data;
+}
+
+
+TEST_CASE(ByteBufferUnlignedAccess) {
+  intptr_t length = 24;
+  uint8_t* data = new uint8_t[length];
+
+  const ByteBuffer& array1 =
+      ByteBuffer::Handle(ByteBuffer::New(data, length));
+  EXPECT(!array1.IsNull());
+  EXPECT_EQ(length, array1.Length());
+
+  const ByteBuffer& array2 =
+      ByteBuffer::Handle(ByteBuffer::New(data, length));
+  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));
+
+  memset(data, 0xAA, ARRAY_SIZE(data));
+  array1.SetUnalignedAt<float>(float_misalign, 0.0f);
+  EXPECT_EQ(0.0f, array2.UnalignedAt<float>(float_misalign));
+  array1.SetUnalignedAt<float>(4 + float_misalign, 1.0f);
+  EXPECT_EQ(1.0f, array2.UnalignedAt<float>(4 + float_misalign));
+
+  int double_misalign = 5;
+  memset(data, 0xAA, ARRAY_SIZE(data));
+  array1.SetUnalignedAt<double>(double_misalign, DBL_MIN);
+  EXPECT_EQ(DBL_MIN, array2.UnalignedAt<double>(double_misalign));
+  array1.SetUnalignedAt<double>(8 + double_misalign, DBL_MAX);
+  EXPECT_EQ(DBL_MAX,
+            array2.UnalignedAt<double>(8 + double_misalign));
+
+  memset(data, 0xAA, ARRAY_SIZE(data));
+  array1.SetUnalignedAt<double>(double_misalign, 0.0);
+  EXPECT_EQ(0.0, array2.UnalignedAt<double>(double_misalign));
+  array1.SetUnalignedAt<double>(8 + double_misalign, 1.0);
+  EXPECT_EQ(1.0, array2.UnalignedAt<double>(8 + double_misalign));
+
+  delete[] data;
+}
+
+
+TEST_CASE(ByteBufferSkewedUnalignedBaseAccess) {
+  intptr_t length = 24;
+  uint8_t* data = new uint8_t[length];
+
+  int skew = 2;
+
+  const ByteBuffer& array1 =
+      ByteBuffer::Handle(ByteBuffer::New(data + 3, length));
+  EXPECT(!array1.IsNull());
+  EXPECT_EQ(length, array1.Length());
+
+  const ByteBuffer& array2 =
+      ByteBuffer::Handle(ByteBuffer::New(data + 1, length));
+  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));
+  array1.SetUnalignedAt<float>(0, 0.0f);
+  EXPECT_EQ(0.0f, array2.UnalignedAt<float>(0 + skew));
+  array2.SetUnalignedAt<float>(4 + skew, 1.0f);
+  EXPECT_EQ(1.0f, array1.UnalignedAt<float>(4));
+
+  memset(data, 0xAA, ARRAY_SIZE(data));
+  array1.SetUnalignedAt<double>(0, DBL_MIN);
+  EXPECT_EQ(DBL_MIN, array2.UnalignedAt<double>(0 + skew));
+  array2.SetUnalignedAt<double>(8 + skew, DBL_MAX);
+  EXPECT_EQ(DBL_MAX, array1.UnalignedAt<double>(8));
+
+  memset(data, 0xAA, ARRAY_SIZE(data));
+  array1.SetUnalignedAt<double>(0, 0.0);
+  EXPECT_EQ(0.0, array2.UnalignedAt<double>(0 + skew));
+  array2.SetUnalignedAt<double>(8 + skew, 1.0);
+  EXPECT_EQ(1.0, array1.UnalignedAt<double>(8));
+
+  delete[] data;
+}
+
+
 TEST_CASE(Script) {
   const char* url_chars = "builtin:test-case";
   const char* source_chars = "This will not compile.";
   const String& url = String::Handle(String::New(url_chars));
   const String& source = String::Handle(String::New(source_chars));
   const Script& script = Script::Handle(Script::New(url,
                                                     source,
                                                     RawScript::kSource));
   EXPECT(!script.IsNull());
   EXPECT(script.IsScript());
@@ skipping 344 matching lines @@
     cls = iterator.GetNextClass();
     ASSERT((cls.raw() == ae66.raw()) || (cls.raw() == re44.raw()));
     count++;
   }
   ASSERT(count == 2);
 }
 
 #endif  // TARGET_ARCH_IA32.
 
 }  // namespace dart