First set of changes towards cleaning up the bytearray access APIs

vm/dart_api_impl_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 "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "platform/utils.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
@@ skipping 186 matching lines @@
 
   // Equal objects.
   EXPECT(!Dart_IdentityEquals(five, five_again));
 
   // Different objects.
   EXPECT(!Dart_IdentityEquals(five, seven));
 
   // Non-instance objects.
   {
     Isolate* isolate = Isolate::Current();
-    DARTSCOPE_NOCHECKS(isolate);
+    DARTSCOPE(isolate);
     Dart_Handle class1 = Api::NewHandle(isolate, Object::null_class());
     Dart_Handle class2 = Api::NewHandle(isolate, Object::class_class());
 
     EXPECT(Dart_IdentityEquals(class1, class1));
 
     EXPECT(!Dart_IdentityEquals(class1, class2));
   }
 }
 
 
@@ skipping 587 matching lines @@
   EXPECT(!Dart_IsByteArrayExternal(byte_array1));
   EXPECT(Dart_IsList(byte_array1));
 
   intptr_t length = 0;
   Dart_Handle result = Dart_ListLength(byte_array1, &length);
   EXPECT_VALID(result);
   EXPECT_EQ(10, length);
 
   result = Dart_ListSetAt(byte_array1, -1, Dart_NewInteger(1));
   EXPECT(Dart_IsError(result));
-  result = Dart_ByteArraySetUint8At(byte_array1, -1, 1);
-  EXPECT(Dart_IsError(result));
 
   result = Dart_ListSetAt(byte_array1, 10, Dart_NewInteger(1));
   EXPECT(Dart_IsError(result));
-  result = Dart_ByteArraySetUint8At(byte_array1, 10, 1);
-  EXPECT(Dart_IsError(result));
 
   // Set through the List API.
   for (intptr_t i = 0; i < 10; ++i) {
     EXPECT_VALID(Dart_ListSetAt(byte_array1, i, Dart_NewInteger(i + 1)));
   }
   for (intptr_t i = 0; i < 10; ++i) {
     // Get through the List API.
     Dart_Handle integer_obj = Dart_ListGetAt(byte_array1, i);
     EXPECT_VALID(integer_obj);
     int64_t int64_t_value = -1;
     EXPECT_VALID(Dart_IntegerToInt64(integer_obj, &int64_t_value));
     EXPECT_EQ(i + 1, int64_t_value);
-    // Get through the ByteArray API.
-    uint8_t uint8_t_value = 0xFF;
-    EXPECT_VALID(Dart_ByteArrayGetUint8At(byte_array1, i, &uint8_t_value));
-    EXPECT_EQ(i + 1, uint8_t_value);
-  }
-
-  // Set through the ByteArray API.
-  for (intptr_t i = 0; i < 10; ++i) {
-    EXPECT_VALID(Dart_ByteArraySetUint8At(byte_array1, i, i + 2));
-  }
-  for (intptr_t i = 0; i < 10; ++i) {
-    // Get through the List API.
-    Dart_Handle integer_obj = Dart_ListGetAt(byte_array1, i);
-    EXPECT_VALID(integer_obj);
-    int64_t int64_t_value = -1;
-    EXPECT_VALID(Dart_IntegerToInt64(integer_obj, &int64_t_value));
-    EXPECT_EQ(i + 2, int64_t_value);
-    // Get through the ByteArray API.
-    uint8_t uint8_t_value = 0xFF;
-    EXPECT_VALID(Dart_ByteArrayGetUint8At(byte_array1, i, &uint8_t_value));
-    EXPECT_EQ(i + 2, uint8_t_value);
   }
 
   Dart_Handle byte_array2 = Dart_NewByteArray(10);
   bool is_equal = false;
   Dart_ObjectEquals(byte_array1, byte_array2, &is_equal);
   EXPECT(!is_equal);
 
   // Set through the List API.
   for (intptr_t i = 0; i < 10; ++i) {
+    result = Dart_ListSetAt(byte_array1, i, Dart_NewInteger(i + 2));
+    EXPECT_VALID(result);
     result = Dart_ListSetAt(byte_array2, i, Dart_NewInteger(i + 2));
     EXPECT_VALID(result);
   }
   for (intptr_t i = 0; i < 10; ++i) {
     // Get through the List API.
     Dart_Handle e1 = Dart_ListGetAt(byte_array1, i);
     Dart_Handle e2 = Dart_ListGetAt(byte_array2, i);
     is_equal = false;
     Dart_ObjectEquals(e1, e2, &is_equal);
     EXPECT(is_equal);
-    // Get through the ByteArray API.
-    uint8_t v1 = 0xFF;
-    uint8_t v2 = 0XFF;
-    EXPECT_VALID(Dart_ByteArrayGetUint8At(byte_array1, i, &v1));
-    EXPECT_VALID(Dart_ByteArrayGetUint8At(byte_array2, i, &v2));
-    EXPECT_NE(v1, 0xFF);
-    EXPECT_NE(v2, 0xFF);
-    EXPECT_EQ(v1, v2);
-  }
-
-  byte_array2 = Dart_NewByteArray(10);
-  is_equal = false;
-  Dart_ObjectEquals(byte_array1, byte_array2, &is_equal);
-  EXPECT(!is_equal);
-
-  // Set through the ByteArray API.
-  for (intptr_t i = 0; i < 10; ++i) {
-    result = Dart_ByteArraySetUint8At(byte_array2, i, i + 2);
-    EXPECT_VALID(result);
-  }
-  for (intptr_t i = 0; i < 10; ++i) {
-    // Get through the List API.
-    Dart_Handle e1 = Dart_ListGetAt(byte_array1, i);
-    Dart_Handle e2 = Dart_ListGetAt(byte_array2, i);
-    is_equal = false;
-    Dart_ObjectEquals(e1, e2, &is_equal);
-    EXPECT(is_equal);
-    // Get through the ByteArray API.
-    uint8_t v1 = 0xFF;
-    uint8_t v2 = 0XFF;
-    EXPECT_VALID(Dart_ByteArrayGetUint8At(byte_array1, i, &v1));
-    EXPECT_VALID(Dart_ByteArrayGetUint8At(byte_array2, i, &v2));
-    EXPECT_NE(v1, 0xFF);
-    EXPECT_NE(v2, 0xFF);
-    EXPECT_EQ(v1, v2);
   }
 
   uint8_t data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-  result = Dart_ListSetAsBytes(byte_array1, 0, data, 10);
-  EXPECT_VALID(result);
-  for (intptr_t i = 0; i < 10; ++i) {
-    Dart_Handle integer_obj = Dart_ListGetAt(byte_array1, i);
-    EXPECT_VALID(integer_obj);
-    int64_t int64_t_value = -1;
-    EXPECT_VALID(Dart_IntegerToInt64(integer_obj, &int64_t_value));
-    EXPECT_EQ(i, int64_t_value);
-    uint8_t uint8_t_value = 0xFF;
-    EXPECT_VALID(Dart_ByteArrayGetUint8At(byte_array1, i, &uint8_t_value));
-    EXPECT_EQ(i, uint8_t_value);
-  }
-
   for (intptr_t i = 0; i < 10; ++i) {
     EXPECT_VALID(Dart_ListSetAt(byte_array1, i, Dart_NewInteger(10 - i)));
   }
   Dart_ListGetAsBytes(byte_array1, 0, data, 10);
   for (intptr_t i = 0; i < 10; ++i) {
     Dart_Handle integer_obj = Dart_ListGetAt(byte_array1, i);
     EXPECT_VALID(integer_obj);
     int64_t int64_t_value = -1;
     EXPECT_VALID(Dart_IntegerToInt64(integer_obj, &int64_t_value));
     EXPECT_EQ(10 - i, int64_t_value);
-    uint8_t uint8_t_value = 0xFF;
-    EXPECT_VALID(Dart_ByteArrayGetUint8At(byte_array1, i, &uint8_t_value));
-    EXPECT_EQ(10 - i, uint8_t_value);
-  }
-
-  for (intptr_t i = 0; i < 10; ++i) {
-    EXPECT_VALID(Dart_ByteArraySetUint8At(byte_array1, i, 10 + i));
-  }
-  Dart_ListGetAsBytes(byte_array1, 0, data, 10);
-  for (intptr_t i = 0; i < 10; ++i) {
-    Dart_Handle integer_obj = Dart_ListGetAt(byte_array1, i);
-    EXPECT_VALID(integer_obj);
-    int64_t int64_t_value = -1;
-    EXPECT_VALID(Dart_IntegerToInt64(integer_obj, &int64_t_value));
-    EXPECT_EQ(10 + i, int64_t_value);
-    uint8_t uint8_t_value = 0xFF;
-    EXPECT_VALID(Dart_ByteArrayGetUint8At(byte_array1, i, &uint8_t_value));
-    EXPECT_EQ(10 + i, uint8_t_value);
   }
 }
 
 
-TEST_CASE(ByteArrayAlignedMultiByteAccess) {
-  intptr_t length = 16;
-  Dart_Handle byte_array = Dart_NewByteArray(length);
-  intptr_t api_length = 0;
-  EXPECT_VALID(Dart_ListLength(byte_array, &api_length));
-  EXPECT_EQ(length, api_length);
+TEST_CASE(ScalarListDirectAccess) {
+  Dart_Handle str = Dart_NewStringFromCString("junk");
+  Dart_Handle byte_array = Dart_NewByteArray(10);
+  EXPECT_VALID(byte_array);
+  Dart_Handle result;
+  result = Dart_ScalarListAcquireData(byte_array, NULL, NULL, NULL);
+  EXPECT_ERROR(result, "Dart_ScalarListAcquireData expects argument 'type'"
+                       " to be non-null.");
+  Dart_Scalar_Type type;
+  result = Dart_ScalarListAcquireData(byte_array, &type, NULL, NULL);
+  EXPECT_ERROR(result, "Dart_ScalarListAcquireData expects argument 'data'"
+                       " to be non-null.");
+  void* data;
+  result = Dart_ScalarListAcquireData(byte_array, &type, &data, NULL);
+  EXPECT_ERROR(result, "Dart_ScalarListAcquireData expects argument 'len'"
+                       " to be non-null.");
+  intptr_t len;
+  result = Dart_ScalarListAcquireData(Dart_Null(), &type, &data, &len);
+  EXPECT_ERROR(result, "Dart_ScalarListAcquireData expects argument 'array'"
+                       " to be non-null.");
+  result = Dart_ScalarListAcquireData(str, &type, &data, &len);
+  EXPECT_ERROR(result, "Dart_ScalarListAcquireData expects argument 'array'"
+                       " to be of type 'scalar list'.");
 
-  // 4-byte aligned sets.
-
-  EXPECT_VALID(Dart_ByteArraySetFloat32At(byte_array, 0, FLT_MIN));
-  EXPECT_VALID(Dart_ByteArraySetFloat32At(byte_array, 4, FLT_MAX));
-
-  float float_value = 0.0f;
-  EXPECT_VALID(Dart_ByteArrayGetFloat32At(byte_array, 0, &float_value));
-  EXPECT_EQ(FLT_MIN, float_value);
-
-  float_value = 0.0f;
-  EXPECT_VALID(Dart_ByteArrayGetFloat32At(byte_array, 4, &float_value));
-  EXPECT_EQ(FLT_MAX, float_value);
-
-  EXPECT_VALID(Dart_ByteArraySetFloat32At(byte_array, 0, 0.0f));
-  float_value = FLT_MAX;
-  EXPECT_VALID(Dart_ByteArrayGetFloat32At(byte_array, 0, &float_value));
-  EXPECT_EQ(0.0f, float_value);
-
-  EXPECT_VALID(Dart_ByteArraySetFloat32At(byte_array, 4, 1.0f));
-  float_value = FLT_MAX;
-  EXPECT_VALID(Dart_ByteArrayGetFloat32At(byte_array, 4, &float_value));
-  EXPECT_EQ(1.0f, float_value);
-
-  EXPECT_VALID(Dart_ByteArraySetFloat32At(byte_array, 0, -1.0f));
-  float_value = FLT_MAX;
-  EXPECT_VALID(Dart_ByteArrayGetFloat32At(byte_array, 0, &float_value));
-  EXPECT_EQ(-1.0f, float_value);
-
-  // 8-byte aligned sets.
-
-  EXPECT_VALID(Dart_ByteArraySetFloat64At(byte_array, 0, DBL_MIN));
-  EXPECT_VALID(Dart_ByteArraySetFloat64At(byte_array, 8, DBL_MAX));
-
-  double double_value = 0.0;
-  EXPECT_VALID(Dart_ByteArrayGetFloat64At(byte_array, 0, &double_value));
-  EXPECT_EQ(DBL_MIN, double_value);
-
-  double_value = 0.0;
-  EXPECT_VALID(Dart_ByteArrayGetFloat64At(byte_array, 8, &double_value));
-  EXPECT_EQ(DBL_MAX, double_value);
-
-  EXPECT_VALID(Dart_ByteArraySetFloat64At(byte_array, 0, 0.0));
-  double_value = DBL_MAX;
-  EXPECT_VALID(Dart_ByteArrayGetFloat64At(byte_array, 0, &double_value));
-  EXPECT_EQ(0.0, double_value);
-
-  EXPECT_VALID(Dart_ByteArraySetFloat64At(byte_array, 8, 1.0));
-  double_value = DBL_MAX;
-  EXPECT_VALID(Dart_ByteArrayGetFloat64At(byte_array, 8, &double_value));
-  EXPECT_EQ(1.0, double_value);
-}
-
-
-TEST_CASE(ByteArrayMisalignedMultiByteAccess) {
-  intptr_t length = 17;
-  Dart_Handle byte_array = Dart_NewByteArray(length);
-  intptr_t api_length = 0;
-  EXPECT_VALID(Dart_ListLength(byte_array, &api_length));
-  EXPECT_EQ(length, api_length);
-
-  // 4-byte misaligned sets.
-
-  EXPECT_VALID(Dart_ByteArraySetFloat32At(byte_array, 1, FLT_MIN));
-  EXPECT_VALID(Dart_ByteArraySetFloat32At(byte_array, 5, FLT_MAX));
-
-  float float_value = 0.0f;
-  EXPECT_VALID(Dart_ByteArrayGetFloat32At(byte_array, 1, &float_value));
-  EXPECT_EQ(FLT_MIN, float_value);
-
-  float_value = 0.0f;
-  EXPECT_VALID(Dart_ByteArrayGetFloat32At(byte_array, 5, &float_value));
-  EXPECT_EQ(FLT_MAX, float_value);
-
-  EXPECT_VALID(Dart_ByteArraySetFloat32At(byte_array, 1, 0.0f));
-  float_value = FLT_MAX;
-  EXPECT_VALID(Dart_ByteArrayGetFloat32At(byte_array, 1, &float_value));
-  EXPECT_EQ(0.0f, float_value);
-
-  EXPECT_VALID(Dart_ByteArraySetFloat32At(byte_array, 5, -0.0f));
-  float_value = FLT_MAX;
-  EXPECT_VALID(Dart_ByteArrayGetFloat32At(byte_array, 5, &float_value));
-  EXPECT_EQ(-0.0f, float_value);
-
-  EXPECT_VALID(Dart_ByteArraySetFloat32At(byte_array, 5, 1.0f));
-  float_value = FLT_MAX;
-  EXPECT_VALID(Dart_ByteArrayGetFloat32At(byte_array, 5, &float_value));
-  EXPECT_EQ(1.0f, float_value);
-
-  EXPECT_VALID(Dart_ByteArraySetFloat32At(byte_array, 1, -1.0f));
-  float_value = FLT_MAX;
-  EXPECT_VALID(Dart_ByteArrayGetFloat32At(byte_array, 1, &float_value));
-  EXPECT_EQ(-1.0f, float_value);
-
-  // 8-byte misaligned sets.
-
-  EXPECT_VALID(Dart_ByteArraySetFloat64At(byte_array, 1, DBL_MIN));
-  EXPECT_VALID(Dart_ByteArraySetFloat64At(byte_array, 9, DBL_MAX));
-
-  double double_value = 0.0;
-  EXPECT_VALID(Dart_ByteArrayGetFloat64At(byte_array, 1, &double_value));
-  EXPECT_EQ(DBL_MIN, double_value);
-
-  double_value = 0.0;
-  EXPECT_VALID(Dart_ByteArrayGetFloat64At(byte_array, 9, &double_value));
-  EXPECT_EQ(DBL_MAX, double_value);
-
-  EXPECT_VALID(Dart_ByteArraySetFloat64At(byte_array, 1, 0.0));
-  double_value = DBL_MAX;
-  EXPECT_VALID(Dart_ByteArrayGetFloat64At(byte_array, 1, &double_value));
-  EXPECT_EQ(0.0, double_value);
-
-  EXPECT_VALID(Dart_ByteArraySetFloat64At(byte_array, 9, -0.0));
-  double_value = DBL_MAX;
-  EXPECT_VALID(Dart_ByteArrayGetFloat64At(byte_array, 9, &double_value));
-  EXPECT_EQ(-0.0, double_value);
-
-  EXPECT_VALID(Dart_ByteArraySetFloat64At(byte_array, 9, 1.0));
-  double_value = DBL_MAX;
-  EXPECT_VALID(Dart_ByteArrayGetFloat64At(byte_array, 9, &double_value));
-  EXPECT_EQ(1.0, double_value);
-
-  EXPECT_VALID(Dart_ByteArraySetFloat64At(byte_array, 1, -1.0));
-  double_value = DBL_MAX;
-  EXPECT_VALID(Dart_ByteArrayGetFloat64At(byte_array, 1, &double_value));
-  EXPECT_EQ(-1.0, double_value);
+  result = Dart_ScalarListReleaseData(Dart_Null());
+  EXPECT_ERROR(result, "Dart_ScalarListReleaseData expects argument 'array'"
+                       " to be non-null.");
+  result = Dart_ScalarListReleaseData(str);
+  EXPECT_ERROR(result, "Dart_ScalarListReleaseData expects argument 'array'"
+                       " to be of type 'scalar list'.");
 }
 
 
 static void ExternalByteArrayAccessTests(Dart_Handle obj,
                                          uint8_t data[],
                                          intptr_t data_length) {
   EXPECT_VALID(obj);
   EXPECT(Dart_IsByteArray(obj));
   EXPECT(Dart_IsByteArrayExternal(obj));
   EXPECT(Dart_IsList(obj));
@@ skipping 138 matching lines @@
   TestIsolateScope __test_isolate__;
 
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   Dart_EnterScope();
   {
     EXPECT(state->top_scope() != NULL);
-    DARTSCOPE_NOCHECKS(isolate);
+    DARTSCOPE(isolate);
     const String& str1 = String::Handle(String::New("Test String"));
     Dart_Handle ref = Api::NewHandle(isolate, str1.raw());
     String& str2 = String::Handle();
     str2 ^= Api::UnwrapHandle(ref);
     EXPECT(str1.Equals(str2));
   }
   Dart_ExitScope();
   EXPECT(scope == state->top_scope());
 }
 
 
 // Unit test for creating and deleting persistent handles.
 UNIT_TEST_CASE(PersistentHandles) {
   const char* kTestString1 = "Test String1";
   const char* kTestString2 = "Test String2";
   TestCase::CreateTestIsolate();
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   Dart_Handle handles[2000];
   Dart_EnterScope();
   {
-    DARTSCOPE_NOCHECKS(isolate);
+    DARTSCOPE(isolate);
     Dart_Handle ref1 = Api::NewHandle(isolate, String::New(kTestString1));
     for (int i = 0; i < 1000; i++) {
       handles[i] = Dart_NewPersistentHandle(ref1);
     }
     Dart_EnterScope();
     Dart_Handle ref2 = Api::NewHandle(isolate, String::New(kTestString2));
     for (int i = 1000; i < 2000; i++) {
       handles[i] = Dart_NewPersistentHandle(ref2);
     }
     for (int i = 500; i < 1500; i++) {
       Dart_DeletePersistentHandle(handles[i]);
     }
     for (int i = 500; i < 1000; i++) {
       handles[i] = Dart_NewPersistentHandle(ref2);
     }
     for (int i = 1000; i < 1500; i++) {
       handles[i] = Dart_NewPersistentHandle(ref1);
     }
     VERIFY_ON_TRANSITION;
     Dart_ExitScope();
   }
   Dart_ExitScope();
   {
     StackZone zone(isolate);
-    DARTSCOPE_NOCHECKS(isolate);
+    HANDLESCOPE(isolate);
     for (int i = 0; i < 500; i++) {
       String& str = String::Handle();
       str ^= Api::UnwrapHandle(handles[i]);
       EXPECT(str.Equals(kTestString1));
     }
     for (int i = 500; i < 1000; i++) {
       String& str = String::Handle();
       str ^= Api::UnwrapHandle(handles[i]);
       EXPECT(str.Equals(kTestString2));
     }
@@ skipping 930 matching lines @@
 UNIT_TEST_CASE(LocalHandles) {
   TestCase::CreateTestIsolate();
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   Dart_Handle handles[300];
   {
     StackZone zone(isolate);
-    DARTSCOPE_NOCHECKS(isolate);
+    HANDLESCOPE(isolate);
     Smi& val = Smi::Handle();
 
     // Start a new scope and allocate some local handles.
     Dart_EnterScope();
     for (int i = 0; i < 100; i++) {
       handles[i] = Api::NewHandle(isolate, Smi::New(i));
     }
     EXPECT_EQ(100, state->CountLocalHandles());
     for (int i = 0; i < 100; i++) {
       val ^= Api::UnwrapHandle(handles[i]);
@@ skipping 639 matching lines @@
   result = Dart_CreateNativeWrapperClass(
       lib,
       NewString("NativeFieldsWrapper"),
       kNumNativeFields);
 
   // Load up a test script in the test library.
 
   // Invoke a function which returns an object of type NativeFields.
   result = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
   EXPECT_VALID(result);
-  DARTSCOPE_NOCHECKS(Isolate::Current());
+  DARTSCOPE(Isolate::Current());
   Instance& obj = Instance::Handle();
   obj ^= Api::UnwrapHandle(result);
   const Class& cls = Class::Handle(obj.clazz());
   // We expect the newly created "NativeFields" object to have
   // 2 dart instance fields (fld1, fld2) and a reference to the native fields.
   // Hence the size of an instance of "NativeFields" should be
   // (1 + 2) * kWordSize + size of object header.
   // We check to make sure the instance size computed by the VM matches
   // our expectations.
   intptr_t header_size = sizeof(RawObject);
@@ skipping 48 matching lines @@
   Dart_Handle result;
   const int kNumNativeFields = 2;
 
   // Load up a test script in the test library.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars,
                                              native_field_lookup);
 
   // Invoke a function which returns an object of type NativeFields.
   result = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
   EXPECT_VALID(result);
-  DARTSCOPE_NOCHECKS(Isolate::Current());
+  DARTSCOPE(Isolate::Current());
   Instance& obj = Instance::Handle();
   obj ^= Api::UnwrapHandle(result);
   const Class& cls = Class::Handle(obj.clazz());
   // We expect the newly created "NativeFields" object to have
   // 2 dart instance fields (fld1, fld2) and a reference to the native fields.
   // Hence the size of an instance of "NativeFields" should be
   // (1 + 2) * kWordSize + size of object header.
   // We check to make sure the instance size computed by the VM matches
   // our expectations.
   intptr_t header_size = sizeof(RawObject);
@@ skipping 234 matching lines @@
       "  static const int fld4 = 10;\n"
       "}\n"
       "NativeFields testMain1() {\n"
       "  NativeFields obj = new NativeFields(10, 20);\n"
       "  return obj;\n"
       "}\n"
       "Function testMain2() {\n"
       "  return () {};\n"
       "}\n";
   Dart_Handle result;
-  DARTSCOPE_NOCHECKS(Isolate::Current());
+  DARTSCOPE(Isolate::Current());
 
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Invoke a function which returns an object of type NativeFields.
   Dart_Handle retobj = Dart_Invoke(lib, NewString("testMain1"), 0, NULL);
   EXPECT_VALID(retobj);
 
   // Now access and set various native instance fields of the returned object.
   // All of these tests are expected to return failure as there are no
@@ skipping 55 matching lines @@
       "}\n"
       "main() {\n"
       "  var snd = spawnFunction(echo);\n"
       "  var obj = new Test(1,2);\n"
       "  snd.send(obj, port.toSendPort());\n"
       "  port.receive((msg, reply) {\n"
       "    print('from worker ${msg}');\n"
       "  });\n"
       "}\n";
 
-  DARTSCOPE_NOCHECKS(Isolate::Current());
+  DARTSCOPE(Isolate::Current());
 
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Invoke 'main' which should spawn an isolate and try to send an
   // object with native fields over to the spawned isolate. This
   // should result in an unhandled exception which is checked.
   Dart_Handle retobj = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT(Dart_IsError(retobj));
 }
@@ skipping 562 matching lines @@
       "}\n"
       "Function getStaticClosure() {\n"
       "  return Foo.getStaticClosure();\n"
       "}\n"
       "Function getStaticClosureWithArgs() {\n"
       "  return Foo.getStaticClosureWithArgs();\n"
       "}\n";
   Dart_Handle result;
   Dart_Handle owner;
   Dart_Handle defining_function;
-  DARTSCOPE_NOCHECKS(Isolate::Current());
+  DARTSCOPE(Isolate::Current());
 
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(lib);
   Dart_Handle cls = Dart_GetClass(lib, NewString("Foo"));
   EXPECT_VALID(cls);
 
   // Invoke a function which returns a closure.
   Dart_Handle retobj = Dart_Invoke(lib, NewString("getClosure"), 0, NULL);
   EXPECT_VALID(retobj);
@@ skipping 147 matching lines @@
       "  static const int fld4 = 10;\n"
       "}\n"
       "Function testMain1() {\n"
       "  InvokeClosure obj = new InvokeClosure(10, 20);\n"
       "  return obj.method1(10);\n"
       "}\n"
       "Function testMain2() {\n"
       "  return InvokeClosure.method2(10);\n"
       "}\n";
   Dart_Handle result;
-  DARTSCOPE_NOCHECKS(Isolate::Current());
+  DARTSCOPE(Isolate::Current());
 
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Invoke a function which returns a closure.
   Dart_Handle retobj = Dart_Invoke(lib, NewString("testMain1"), 0, NULL);
   EXPECT_VALID(retobj);
 
   EXPECT(Dart_IsClosure(retobj));
   EXPECT(!Dart_IsClosure(Dart_NewInteger(101)));
@@ skipping 2842 matching lines @@
 }
 
 
 // Allocates an object in new space and assigns it a peer.  Allows the
 // peer referent to be garbage collected and checks that the count of
 // peer objects is decremented by one.
 TEST_CASE(CollectOneNewSpacePeer) {
   Isolate* isolate = Isolate::Current();
   Dart_EnterScope();
   {
-    DARTSCOPE_NOCHECKS(isolate);
+    DARTSCOPE(isolate);
     Dart_Handle str = NewString("a string");
     EXPECT_VALID(str);
     EXPECT(Dart_IsString(str));
     EXPECT_EQ(0, isolate->heap()->PeerCount());
     void* out = &out;
     EXPECT_VALID(Dart_GetPeer(str, &out));
     EXPECT(out == NULL);
     int peer = 1234;
     EXPECT_VALID(Dart_SetPeer(str, &peer));
     EXPECT_EQ(1, isolate->heap()->PeerCount());
@@ skipping 52 matching lines @@
 }
 
 
 // Allocates two objects in new space and assigns them a peer.  Allow
 // the peer referents to be garbage collected and check that the count
 // of peer objects is decremented by two.
 TEST_CASE(CollectTwoNewSpacePeers) {
   Isolate* isolate = Isolate::Current();
   Dart_EnterScope();
   {
-    DARTSCOPE_NOCHECKS(isolate);
+    DARTSCOPE(isolate);
     Dart_Handle s1 = NewString("s1");
     EXPECT_VALID(s1);
     EXPECT(Dart_IsString(s1));
     EXPECT_EQ(0, isolate->heap()->PeerCount());
     void* o1 = &o1;
     EXPECT(Dart_GetPeer(s1, &o1));
     EXPECT(o1 == NULL);
     int p1 = 1234;
     EXPECT_VALID(Dart_SetPeer(s1, &p1));
     EXPECT_EQ(1, isolate->heap()->PeerCount());
@@ skipping 63 matching lines @@
   EXPECT(out == NULL);
   int peer = 1234;
   EXPECT_VALID(Dart_SetPeer(str, &peer));
   out = &out;
   EXPECT(Dart_GetPeer(str, &out));
   EXPECT(out == reinterpret_cast<void*>(&peer));
   EXPECT_EQ(1, isolate->heap()->PeerCount());
   isolate->heap()->CollectGarbage(Heap::kNew);
   isolate->heap()->CollectGarbage(Heap::kNew);
   {
-    DARTSCOPE_NOCHECKS(isolate);
+    DARTSCOPE(isolate);
     String& handle = String::Handle();
     handle ^= Api::UnwrapHandle(str);
     EXPECT(handle.IsOld());
   }
   EXPECT_VALID(Dart_GetPeer(str, &out));
   EXPECT(out == reinterpret_cast<void*>(&peer));
   EXPECT_EQ(1, isolate->heap()->PeerCount());
   EXPECT_VALID(Dart_SetPeer(str, NULL));
   out = &out;
   EXPECT_VALID(Dart_GetPeer(str, &out));
@@ skipping 32 matching lines @@
 }
 
 
 // Allocates an object in old space and assigns it a peer.  Allow the
 // peer referent to be garbage collected and check that the count of
 // peer objects is decremented by one.
 TEST_CASE(CollectOneOldSpacePeer) {
   Isolate* isolate = Isolate::Current();
   Dart_EnterScope();
   {
-    DARTSCOPE_NOCHECKS(isolate);
+    DARTSCOPE(isolate);
     Dart_Handle str = Api::NewHandle(isolate, String::New("str", Heap::kOld));
     EXPECT_VALID(str);
     EXPECT(Dart_IsString(str));
     EXPECT_EQ(0, isolate->heap()->PeerCount());
     void* out = &out;
     EXPECT(Dart_GetPeer(str, &out));
     EXPECT(out == NULL);
     int peer = 1234;
     EXPECT_VALID(Dart_SetPeer(str, &peer));
     EXPECT_EQ(1, isolate->heap()->PeerCount());
@@ skipping 55 matching lines @@
 }
 
 
 // Allocates two objects in old space and assigns them a peer.  Allows
 // the peer referents to be garbage collected and checks that the
 // count of peer objects is decremented by two.
 TEST_CASE(CollectTwoOldSpacePeers) {
   Isolate* isolate = Isolate::Current();
   Dart_EnterScope();
   {
-    DARTSCOPE_NOCHECKS(isolate);
+    DARTSCOPE(isolate);
     Dart_Handle s1 = Api::NewHandle(isolate, String::New("s1", Heap::kOld));
     EXPECT_VALID(s1);
     EXPECT(Dart_IsString(s1));
     EXPECT_EQ(0, isolate->heap()->PeerCount());
     void* o1 = &o1;
     EXPECT(Dart_GetPeer(s1, &o1));
     EXPECT(o1 == NULL);
     int p1 = 1234;
     EXPECT_VALID(Dart_SetPeer(s1, &p1));
     EXPECT_EQ(1, isolate->heap()->PeerCount());
@@ skipping 293 matching lines @@
                                    NULL);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(260, value);
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart