Remove the deprecated method invocation and field access apis from the

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/utils.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"
 #include "vm/thread.h"
 #include "vm/unit_test.h"
 #include "vm/verifier.h"
 
 namespace dart {
 
 // Only ia32 and x64 can run execution tests.
 #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64)
 
 TEST_CASE(ErrorHandles) {
   const char* kScriptChars =
-      "class TestClass  {\n"
-      "  static void testMain() {\n"
-      "    throw new Exception(\"bad news\");\n"
-      "  }\n"
+      "void testMain() {\n"
+      "  throw new Exception(\"bad news\");\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   Dart_Handle instance = Dart_True();
   Dart_Handle error = Api::NewError("myerror");
-  Dart_Handle exception = Dart_InvokeStatic(lib,
-                                            Dart_NewString("TestClass"),
-                                            Dart_NewString("testMain"),
-                                            0,
-                                            NULL);
+  Dart_Handle exception = Dart_Invoke(lib,
+                                      Dart_NewString("testMain"),
+                                      0,
+                                      NULL);
 
   EXPECT(!Dart_IsError(instance));
   EXPECT(Dart_IsError(error));
   EXPECT(Dart_IsError(exception));
 
   EXPECT(!Dart_ErrorHasException(instance));
   EXPECT(!Dart_ErrorHasException(error));
   EXPECT(Dart_ErrorHasException(exception));
 
   EXPECT_STREQ("", Dart_GetError(instance));
   EXPECT_STREQ("myerror", Dart_GetError(error));
   EXPECT_STREQ(
       "Unhandled exception:\n"
       "Exception: bad news\n"
-      " 0. Function: 'TestClass.testMain' url: 'dart:test-lib' line:3 col:5\n",
+      " 0. Function: '::testMain' url: 'dart:test-lib' line:2 col:3\n",
       Dart_GetError(exception));
 
   EXPECT(Dart_IsError(Dart_ErrorGetException(instance)));
   EXPECT(Dart_IsError(Dart_ErrorGetException(error)));
   EXPECT_VALID(Dart_ErrorGetException(exception));
 
   EXPECT(Dart_IsError(Dart_ErrorGetStacktrace(instance)));
   EXPECT(Dart_IsError(Dart_ErrorGetStacktrace(error)));
   EXPECT_VALID(Dart_ErrorGetStacktrace(exception));
 }
@@ skipping 12 matching lines @@
 
 
 static Dart_NativeFunction PropagateError_native_lookup(
     Dart_Handle name, int argument_count) {
   return reinterpret_cast<Dart_NativeFunction>(&PropagateErrorNative);
 }
 
 
 TEST_CASE(Dart_PropagateError) {
   const char* kScriptChars =
-      "class Test {\n"
-      "  static void raiseCompileError() {\n"
-      "    return badIdent;\n"
-      "  }\n"
+      "void raiseCompileError() {\n"
+      "  return badIdent;\n"
+      "}\n"
       "\n"
-      "  static void throwException() {\n"
-      "    throw new Exception('myException');\n"
-      "  }\n"
-      "  static void nativeFunc(closure) native 'Test_nativeFunc';\n"
+      "void throwException() {\n"
+      "  throw new Exception('myException');\n"
+      "}\n"
       "\n"
-      "  static void Func1() {\n"
-      "    nativeFunc(() => raiseCompileError());\n"
-      "  }\n"
+      "void nativeFunc(closure) native 'Test_nativeFunc';\n"
       "\n"
-      "  static void Func2() {\n"
-      "    nativeFunc(() => throwException());\n"
-      "  }\n"
+      "void Func1() {\n"
+      "  nativeFunc(() => raiseCompileError());\n"
+      "}\n"
+      "\n"
+      "void Func2() {\n"
+      "  nativeFunc(() => throwException());\n"
       "}\n";
   Dart_Handle lib = TestCase::LoadTestScript(
       kScriptChars, &PropagateError_native_lookup);
   Dart_Handle result;
 
-  result = Dart_InvokeStatic(lib,
-                             Dart_NewString("Test"),
-                             Dart_NewString("Func1"),
-                             0,
-                             NULL);
+  result = Dart_Invoke(lib, Dart_NewString("Func1"), 0, NULL);
   EXPECT(Dart_IsError(result));
   EXPECT(!Dart_ErrorHasException(result));
   EXPECT_SUBSTRING("badIdent", Dart_GetError(result));
 
-  result = Dart_InvokeStatic(lib,
-                             Dart_NewString("Test"),
-                             Dart_NewString("Func2"),
-                             0,
-                             NULL);
+  result = Dart_Invoke(lib, Dart_NewString("Func2"), 0, NULL);
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_ErrorHasException(result));
   EXPECT_SUBSTRING("myException", Dart_GetError(result));
 }
 
 #endif
 
 
 TEST_CASE(Dart_Error) {
   Dart_Handle error = Dart_Error("An %s", "error");
@@ skipping 132 matching lines @@
   EXPECT_EQ(kDoubleVal2, out2);
 }
 
 
 // Only ia32 and x64 can run execution tests.
 #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64)
 
 TEST_CASE(NumberValues) {
   // TODO(antonm): add various kinds of ints (smi, mint, bigint).
   const char* kScriptChars =
-      "class NumberValuesHelper {\n"
-      "  static int getInt() { return 1; }\n"
-      "  static double getDouble() { return 1.0; }\n"
-      "  static bool getBool() { return false; }\n"
-      "  static getNull() { return null; }\n"
-      "}\n";
+      "int getInt() { return 1; }\n"
+      "double getDouble() { return 1.0; }\n"
+      "bool getBool() { return false; }\n"
+      "getNull() { return null; }\n";
   Dart_Handle result;
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
-  Dart_Handle class_name = Dart_NewString("NumberValuesHelper");
   // Check int case.
-  result = Dart_InvokeStatic(lib,
-                             class_name,
-                             Dart_NewString("getInt"),
-                             0,
-                             NULL);
+  result = Dart_Invoke(lib, Dart_NewString("getInt"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsNumber(result));
 
   // Check double case.
-  result = Dart_InvokeStatic(lib,
-                             class_name,
-                             Dart_NewString("getDouble"),
-                             0,
-                             NULL);
+  result = Dart_Invoke(lib, Dart_NewString("getDouble"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsNumber(result));
 
   // Check bool case.
-  result = Dart_InvokeStatic(lib,
-                             class_name,
-                             Dart_NewString("getBool"),
-                             0,
-                             NULL);
+  result = Dart_Invoke(lib, Dart_NewString("getBool"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(!Dart_IsNumber(result));
 
   // Check null case.
-  result = Dart_InvokeStatic(lib,
-                             class_name,
-                             Dart_NewString("getNull"),
-                             0,
-                             NULL);
+  result = Dart_Invoke(lib, Dart_NewString("getNull"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(!Dart_IsNumber(result));
 }
 
 #endif
 
 
 TEST_CASE(IntegerValues) {
   const int64_t kIntegerVal1 = 100;
   const int64_t kIntegerVal2 = 0xffffffff;
@@ skipping 289 matching lines @@
   EXPECT_EQ(peer32, 42);
   Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
   EXPECT_EQ(peer8, 80);
   EXPECT_EQ(peer16, 82);
   EXPECT_EQ(peer32, 84);
 }
 
 
 TEST_CASE(ListAccess) {
   const char* kScriptChars =
-      "class ListAccessTest {"
-      "  ListAccessTest() {}"
-      "  static List testMain() {"
-      "    List a = new List();"
-      "    a.add(10);"
-      "    a.add(20);"
-      "    a.add(30);"
-      "    return a;"
-      "  }"
+      "List testMain() {"
+      "  List a = new List();"
+      "  a.add(10);"
+      "  a.add(20);"
+      "  a.add(30);"
+      "  return a;"
       "}";
   Dart_Handle result;
 
   // 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 InstanceOf..
-  result = Dart_InvokeStatic(lib,
-                             Dart_NewString("ListAccessTest"),
-                             Dart_NewString("testMain"),
-                             0,
-                             NULL);
+  // Invoke a function which returns an object of type List.
+  result = Dart_Invoke(lib, Dart_NewString("testMain"), 0, NULL);
   EXPECT_VALID(result);
 
   // First ensure that the returned object is an array.
   Dart_Handle ListAccessTestObj = result;
 
   EXPECT(Dart_IsList(ListAccessTestObj));
 
   // Get length of array object.
   intptr_t len = 0;
   result = Dart_ListLength(ListAccessTestObj, &len);
@@ skipping 1680 matching lines @@
       "var _gs_fld6;\n"
       "\n"
       "Fields test() {\n"
       "  Fields.Init();\n"
       "  top_fld = 'top';\n"
       "  _top_fld = 'hidden top';\n"
       "  top_getset_fld = 'top getset';\n"
       "  _top_getset_fld = 'hidden top getset';\n"
       "  return new Fields();\n"
       "}\n";
+  const char* kImportedScriptChars =
+      "#library('library_name');\n"
+      "var imported_fld = 'imported';\n"
+      "var _imported_fld = 'hidden imported';\n"
+      "get imported_getset_fld() { return _gs_fld1; }\n"
+      "void set imported_getset_fld(var value) { _gs_fld1 = value; }\n"
+      "get _imported_getset_fld() { return _gs_fld2; }\n"
+      "void set _imported_getset_fld(var value) { _gs_fld2 = value; }\n"
+      "var _gs_fld1;\n"
+      "var _gs_fld2;\n"
+      "void test2() {\n"
+      "  imported_getset_fld = 'imported getset';\n"
+      "  _imported_getset_fld = 'hidden imported getset';\n"
+      "}\n";
 
   // Shared setup.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   Dart_Handle cls = Dart_GetClass(lib, Dart_NewString("Fields"));
   EXPECT_VALID(cls);
-  Dart_Handle instance = Dart_InvokeStatic(lib,
-                                           Dart_Null(),
-                                           Dart_NewString("test"),
-                                           0,
-                                           NULL);
+  Dart_Handle instance = Dart_Invoke(lib, Dart_NewString("test"), 0, NULL);
   EXPECT_VALID(instance);
   Dart_Handle name;
 
+  // Load imported lib.
+  Dart_Handle url = Dart_NewString("library_url");
+  Dart_Handle source = Dart_NewString(kImportedScriptChars);
+  Dart_Handle import_map = Dart_NewList(0);
+  Dart_Handle imported_lib = Dart_LoadLibrary(url, source, import_map);
+  EXPECT_VALID(imported_lib);
+  Dart_Handle result = Dart_LibraryImportLibrary(lib, imported_lib);
+  EXPECT_VALID(result);
+  result = Dart_Invoke(imported_lib, Dart_NewString("test2"), 0, NULL);
+  EXPECT_VALID(result);
+
   // Instance field.
   name = Dart_NewString("instance_fld");
   TestFieldNotFound(lib, name);
   TestFieldNotFound(cls, name);
   TestFieldOk(instance, name, false, "instance");
 
   // Hidden instance field.
   name = Dart_NewString("_instance_fld");
   TestFieldNotFound(lib, name);
   TestFieldNotFound(cls, name);
@@ skipping 99 matching lines @@
   name = Dart_NewString("top_getset_fld");
   TestFieldNotFound(cls, name);
   TestFieldNotFound(instance, name);
   TestFieldOk(lib, name, false, "top getset");
 
   // Hidden top-level get/set field.
   name = Dart_NewString("_top_getset_fld");
   TestFieldNotFound(cls, name);
   TestFieldNotFound(instance, name);
   TestFieldOk(lib, name, false, "hidden top getset");
+
+  // Imported top-Level field.
+  name = Dart_NewString("imported_fld");
+  TestFieldNotFound(cls, name);
+  TestFieldNotFound(instance, name);
+  TestFieldOk(lib, name, false, "imported");
+
+  // Hidden imported top-level field.  Not found at any level.
+  name = Dart_NewString("_imported_fld");
+  TestFieldNotFound(cls, name);
+  TestFieldNotFound(instance, name);
+  TestFieldNotFound(lib, name);
+
+  // Imported top-Level get/set field.
+  name = Dart_NewString("imported_getset_fld");
+  TestFieldNotFound(cls, name);
+  TestFieldNotFound(instance, name);
+  TestFieldOk(lib, name, false, "imported getset");
+
+  // Hidden imported top-level get/set field.  Not found at any level.
+  name = Dart_NewString("_imported_getset_fld");
+  TestFieldNotFound(cls, name);
+  TestFieldNotFound(instance, name);
+  TestFieldNotFound(lib, name);
 }
 
 
 TEST_CASE(SetField_FunnyValue) {
   const char* kScriptChars =
       "var top;\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   Dart_Handle name = Dart_NewString("top");
   bool value;
@@ skipping 18 matching lines @@
   EXPECT_STREQ("Dart_SetField expects argument 'value' to be of type Instance.",
                Dart_GetError(result));
 
   // Pass an error handle.  The error is contagious.
   result = Dart_SetField(lib, name, Api::NewError("myerror"));
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("myerror", Dart_GetError(result));
 }
 
 
-TEST_CASE(FieldAccessOld) {
-  const char* kScriptChars =
-      "class Fields  {\n"
-      "  Fields(int i, int j) : fld1 = i, fld2 = j {}\n"
-      "  int fld1;\n"
-      "  final int fld2;\n"
-      "  static int fld3;\n"
-      "  static final int fld4 = 10;\n"
-      "}\n"
-      "class FieldsTest {\n"
-      "  static Fields testMain() {\n"
-      "    Fields obj = new Fields(10, 20);\n"
-      "    return obj;\n"
-      "  }\n"
-      "}\n";
-  Dart_Handle result;
-  // 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.
-  Dart_Handle retobj = Dart_InvokeStatic(lib,
-                                         Dart_NewString("FieldsTest"),
-                                         Dart_NewString("testMain"),
-                                         0,
-                                         NULL);
-  EXPECT_VALID(retobj);
-
-  // Now access and set various static fields of Fields class.
-  Dart_Handle cls = Dart_GetClass(lib, Dart_NewString("Fields"));
-  EXPECT_VALID(cls);
-  result = Dart_GetStaticField(cls, Dart_NewString("fld1"));
-  EXPECT(Dart_IsError(result));
-  result = Dart_GetInstanceField(retobj, Dart_NewString("fld3"));
-  EXPECT(Dart_IsError(result));
-  result = Dart_GetStaticField(cls, Dart_NewString("fld4"));
-  EXPECT_VALID(result);
-  int64_t value = 0;
-  result = Dart_IntegerToInt64(result, &value);
-  EXPECT_EQ(10, value);
-  result = Dart_SetStaticField(cls,
-                               Dart_NewString("fld4"),
-                               Dart_NewInteger(20));
-  EXPECT(Dart_IsError(result));
-  result = Dart_GetStaticField(cls, Dart_NewString("fld3"));
-  EXPECT_VALID(result);
-  result = Dart_SetStaticField(cls,
-                               Dart_NewString("fld3"),
-                               Dart_NewInteger(200));
-  EXPECT_VALID(result);
-  result = Dart_IntegerToInt64(result, &value);
-  EXPECT_EQ(200, value);
-
-  // Now access and set various instance fields of the returned object.
-  result = Dart_GetInstanceField(retobj, Dart_NewString("fld3"));
-  EXPECT(Dart_IsError(result));
-  result = Dart_GetInstanceField(retobj, Dart_NewString("fld1"));
-  EXPECT_VALID(result);
-  result = Dart_IntegerToInt64(result, &value);
-  EXPECT_EQ(10, value);
-  result = Dart_GetInstanceField(retobj, Dart_NewString("fld2"));
-  EXPECT_VALID(result);
-  result = Dart_IntegerToInt64(result, &value);
-  EXPECT_EQ(20, value);
-  result = Dart_SetInstanceField(retobj,
-                                 Dart_NewString("fld2"),
-                                 Dart_NewInteger(40));
-  EXPECT(Dart_IsError(result));
-  result = Dart_SetInstanceField(retobj,
-                                 Dart_NewString("fld1"),
-                                 Dart_NewInteger(40));
-  EXPECT_VALID(result);
-  result = Dart_GetInstanceField(retobj, Dart_NewString("fld1"));
-  EXPECT_VALID(result);
-  result = Dart_IntegerToInt64(result, &value);
-  EXPECT_EQ(40, value);
-}
-
-
-TEST_CASE(HiddenFieldAccess) {
-  const char* kScriptChars =
-      "class HiddenFields  {\n"
-      "  HiddenFields(int i, int j) : _fld1 = i, _fld2 = j {}\n"
-      "  int _fld1;\n"
-      "  final int _fld2;\n"
-      "  static int _fld3;\n"
-      "  static final int _fld4 = 10;\n"
-      "}\n"
-      "class HiddenFieldsTest {\n"
-      "  static HiddenFields testMain() {\n"
-      "    HiddenFields obj = new HiddenFields(10, 20);\n"
-      "    return obj;\n"
-      "  }\n"
-      "}\n";
-  Dart_Handle result;
-  // Load up a test script which extends the native wrapper class.
-  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
-
-  // Invoke a function which returns an object.
-  Dart_Handle retobj = Dart_InvokeStatic(lib,
-                                         Dart_NewString("HiddenFieldsTest"),
-                                         Dart_NewString("testMain"),
-                                         0,
-                                         NULL);
-  EXPECT_VALID(retobj);
-
-  // Now access and set various static fields of HiddenFields class.
-  Dart_Handle cls = Dart_GetClass(lib, Dart_NewString("HiddenFields"));
-  EXPECT_VALID(cls);
-  result = Dart_GetStaticField(cls, Dart_NewString("_fld1"));
-  EXPECT(Dart_IsError(result));
-  result = Dart_GetInstanceField(retobj, Dart_NewString("_fld3"));
-  EXPECT(Dart_IsError(result));
-  result = Dart_GetStaticField(cls, Dart_NewString("_fld4"));
-  EXPECT_VALID(result);
-  int64_t value = 0;
-  result = Dart_IntegerToInt64(result, &value);
-  EXPECT_EQ(10, value);
-  result = Dart_SetStaticField(cls,
-                               Dart_NewString("_fld4"),
-                               Dart_NewInteger(20));
-  EXPECT(Dart_IsError(result));
-  result = Dart_GetStaticField(cls, Dart_NewString("_fld3"));
-  EXPECT_VALID(result);
-  result = Dart_SetStaticField(cls,
-                               Dart_NewString("_fld3"),
-                               Dart_NewInteger(200));
-  EXPECT_VALID(result);
-  result = Dart_IntegerToInt64(result, &value);
-  EXPECT_EQ(200, value);
-
-  // Now access and set various instance fields of the returned object.
-  result = Dart_GetInstanceField(retobj, Dart_NewString("_fld3"));
-  EXPECT(Dart_IsError(result));
-  result = Dart_GetInstanceField(retobj, Dart_NewString("_fld1"));
-  EXPECT_VALID(result);
-  result = Dart_IntegerToInt64(result, &value);
-  EXPECT_EQ(10, value);
-  result = Dart_GetInstanceField(retobj, Dart_NewString("_fld2"));
-  EXPECT_VALID(result);
-  result = Dart_IntegerToInt64(result, &value);
-  EXPECT_EQ(20, value);
-  result = Dart_SetInstanceField(retobj,
-                                 Dart_NewString("_fld2"),
-                                 Dart_NewInteger(40));
-  EXPECT(Dart_IsError(result));
-  result = Dart_SetInstanceField(retobj,
-                                 Dart_NewString("_fld1"),
-                                 Dart_NewInteger(40));
-  EXPECT_VALID(result);
-  result = Dart_GetInstanceField(retobj, Dart_NewString("_fld1"));
-  EXPECT_VALID(result);
-  result = Dart_IntegerToInt64(result, &value);
-  EXPECT_EQ(40, value);
-}
-
-
 void NativeFieldLookup(Dart_NativeArguments args) {
   UNREACHABLE();
 }
 
 
 static Dart_NativeFunction native_field_lookup(Dart_Handle name,
                                                int argument_count) {
   return reinterpret_cast<Dart_NativeFunction>(&NativeFieldLookup);
 }
 
 
 TEST_CASE(InjectNativeFields1) {
   const char* kScriptChars =
       "class NativeFields extends NativeFieldsWrapper {\n"
       "  NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
       "  int fld1;\n"
       "  final int fld2;\n"
       "  static int fld3;\n"
       "  static final int fld4 = 10;\n"
       "}\n"
-      "class NativeFieldsTest {\n"
-      "  static NativeFields testMain() {\n"
-      "    NativeFields obj = new NativeFields(10, 20);\n"
-      "    return obj;\n"
-      "  }\n"
+      "NativeFields testMain() {\n"
+      "  NativeFields obj = new NativeFields(10, 20);\n"
+      "  return obj;\n"
       "}\n";
   Dart_Handle result;
 
   const int kNumNativeFields = 4;
 
   // Create a test library.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars,
                                              native_field_lookup);
 
   // Create a native wrapper class with native fields.
   result = Dart_CreateNativeWrapperClass(
       lib,
       Dart_NewString("NativeFieldsWrapper"),
       kNumNativeFields);
 
   // Load up a test script in the test library.
 
   // Invoke a function which returns an object of type NativeFields.
-  result = Dart_InvokeStatic(lib,
-                             Dart_NewString("NativeFieldsTest"),
-                             Dart_NewString("testMain"),
-                             0,
-                             NULL);
+  result = Dart_Invoke(lib, Dart_NewString("testMain"), 0, NULL);
   EXPECT_VALID(result);
   DARTSCOPE_NOCHECKS(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 kNumNativeFields native fields.
   // Hence the size of an instance of "NativeFields" should be
   // (kNumNativeFields + 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);
   EXPECT_EQ(Utils::RoundUp(((kNumNativeFields + 2) * kWordSize) + header_size,
                            kObjectAlignment),
             cls.instance_size());
 }
 
 
 TEST_CASE(InjectNativeFields2) {
   const char* kScriptChars =
       "class NativeFields extends NativeFieldsWrapper {\n"
       "  NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
       "  int fld1;\n"
       "  final int fld2;\n"
       "  static int fld3;\n"
       "  static final int fld4 = 10;\n"
       "}\n"
-      "class NativeFieldsTest {\n"
-      "  static NativeFields testMain() {\n"
-      "    NativeFields obj = new NativeFields(10, 20);\n"
-      "    return obj;\n"
-      "  }\n"
+      "NativeFields testMain() {\n"
+      "  NativeFields obj = new NativeFields(10, 20);\n"
+      "  return obj;\n"
       "}\n";
   Dart_Handle result;
   // 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.
-  result = Dart_InvokeStatic(lib,
-                             Dart_NewString("NativeFieldsTest"),
-                             Dart_NewString("testMain"),
-                             0,
-                             NULL);
+  result = Dart_Invoke(lib, Dart_NewString("testMain"), 0, NULL);
+
   // We expect this to fail as class "NativeFields" extends
   // "NativeFieldsWrapper" and there is no definition of it either
   // in the dart code or through the native field injection mechanism.
   EXPECT(Dart_IsError(result));
 }
 
 
 TEST_CASE(InjectNativeFields3) {
   const char* kScriptChars =
       "#import('dart:nativewrappers');"
       "class NativeFields extends NativeFieldWrapperClass2 {\n"
       "  NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
       "  int fld1;\n"
       "  final int fld2;\n"
       "  static int fld3;\n"
       "  static final int fld4 = 10;\n"
       "}\n"
-      "class NativeFieldsTest {\n"
-      "  static NativeFields testMain() {\n"
-      "    NativeFields obj = new NativeFields(10, 20);\n"
-      "    return obj;\n"
-      "  }\n"
+      "NativeFields testMain() {\n"
+      "  NativeFields obj = new NativeFields(10, 20);\n"
+      "  return obj;\n"
       "}\n";
   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_InvokeStatic(lib,
-                             Dart_NewString("NativeFieldsTest"),
-                             Dart_NewString("testMain"),
-                             0,
-                             NULL);
+  result = Dart_Invoke(lib, Dart_NewString("testMain"), 0, NULL);
   EXPECT_VALID(result);
   DARTSCOPE_NOCHECKS(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 kNumNativeFields native fields.
   // Hence the size of an instance of "NativeFields" should be
   // (kNumNativeFields + 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);
   EXPECT_EQ(Utils::RoundUp(((kNumNativeFields + 2) * kWordSize) + header_size,
                            kObjectAlignment),
             cls.instance_size());
 }
 
 
 TEST_CASE(InjectNativeFields4) {
   const char* kScriptChars =
       "#import('dart:nativewrappers');"
       "class NativeFields extends NativeFieldWrapperClass2 {\n"
       "  NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
       "  int fld1;\n"
       "  final int fld2;\n"
       "  static int fld3;\n"
       "  static final int fld4 = 10;\n"
       "}\n"
-      "class NativeFieldsTest {\n"
-      "  static NativeFields testMain() {\n"
-      "    NativeFields obj = new NativeFields(10, 20);\n"
-      "    return obj;\n"
-      "  }\n"
+      "NativeFields testMain() {\n"
+      "  NativeFields obj = new NativeFields(10, 20);\n"
+      "  return obj;\n"
       "}\n";
   Dart_Handle result;
   // Load up a test script in the test library.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Invoke a function which returns an object of type NativeFields.
-  result = Dart_InvokeStatic(lib,
-                             Dart_NewString("NativeFieldsTest"),
-                             Dart_NewString("testMain"),
-                             0,
-                             NULL);
+  result = Dart_Invoke(lib, Dart_NewString("testMain"), 0, NULL);
+
   // We expect the test script to fail finalization with the error below:
   EXPECT(Dart_IsError(result));
   Dart_Handle expected_error = Dart_Error(
       "'dart:test-lib': Error: line 1 pos 38: "
       "class 'NativeFields' is trying to extend a native fields class, "
       "but library '%s' has no native resolvers",
       TestCase::url());
   EXPECT_SUBSTRING(Dart_GetError(expected_error), Dart_GetError(result));
 }
 
 
 static void TestNativeFields(Dart_Handle retobj) {
   // Access and set various instance fields of the object.
-  Dart_Handle result = Dart_GetInstanceField(retobj, Dart_NewString("fld3"));
+  Dart_Handle result = Dart_GetField(retobj, Dart_NewString("fld3"));
   EXPECT(Dart_IsError(result));
-  result = Dart_GetInstanceField(retobj, Dart_NewString("fld0"));
+  result = Dart_GetField(retobj, Dart_NewString("fld0"));
   EXPECT_VALID(result);
   EXPECT(Dart_IsNull(result));
-  result = Dart_GetInstanceField(retobj, Dart_NewString("fld1"));
+  result = Dart_GetField(retobj, Dart_NewString("fld1"));
   EXPECT_VALID(result);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(10, value);
-  result = Dart_GetInstanceField(retobj, Dart_NewString("fld2"));
+  result = Dart_GetField(retobj, Dart_NewString("fld2"));
   EXPECT_VALID(result);
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(20, value);
-  result = Dart_SetInstanceField(retobj,
-                                 Dart_NewString("fld2"),
-                                 Dart_NewInteger(40));
+  result = Dart_SetField(retobj,
+                         Dart_NewString("fld2"),
+                         Dart_NewInteger(40));
   EXPECT(Dart_IsError(result));
-  result = Dart_SetInstanceField(retobj,
-                                 Dart_NewString("fld1"),
-                                 Dart_NewInteger(40));
+  result = Dart_SetField(retobj,
+                         Dart_NewString("fld1"),
+                         Dart_NewInteger(40));
   EXPECT_VALID(result);
-  result = Dart_GetInstanceField(retobj, Dart_NewString("fld1"));
+  result = Dart_GetField(retobj, Dart_NewString("fld1"));
   EXPECT_VALID(result);
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(40, value);
 
   // Now access and set various native instance fields of the returned object.
   const int kNativeFld0 = 0;
   const int kNativeFld1 = 1;
   const int kNativeFld2 = 2;
   const int kNativeFld3 = 3;
   const int kNativeFld4 = 4;
@@ skipping 21 matching lines @@
   result = Dart_SetNativeInstanceField(retobj, kNativeFld2, 400);
   EXPECT_VALID(result);
   result = Dart_SetNativeInstanceField(retobj, kNativeFld3, 4000);
   EXPECT_VALID(result);
   result = Dart_GetNativeInstanceField(retobj, kNativeFld3, &field_value);
   EXPECT_VALID(result);
   EXPECT_EQ(4000, field_value);
 
   // Now re-access various dart instance fields of the returned object
   // to ensure that there was no corruption while setting native fields.
-  result = Dart_GetInstanceField(retobj, Dart_NewString("fld1"));
+  result = Dart_GetField(retobj, Dart_NewString("fld1"));
   EXPECT_VALID(result);
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(40, value);
-  result = Dart_GetInstanceField(retobj, Dart_NewString("fld2"));
+  result = Dart_GetField(retobj, Dart_NewString("fld2"));
   EXPECT_VALID(result);
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(20, value);
 }
 
 
 TEST_CASE(NativeFieldAccess) {
   const char* kScriptChars =
       "class NativeFields extends NativeFieldsWrapper {\n"
       "  NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
       "  int fld0;\n"
       "  int fld1;\n"
       "  final int fld2;\n"
       "  static int fld3;\n"
       "  static final int fld4 = 10;\n"
       "}\n"
-      "class NativeFieldsTest {\n"
-      "  static NativeFields testMain() {\n"
-      "    NativeFields obj = new NativeFields(10, 20);\n"
-      "    return obj;\n"
-      "  }\n"
+      "NativeFields testMain() {\n"
+      "  NativeFields obj = new NativeFields(10, 20);\n"
+      "  return obj;\n"
       "}\n";
   const int kNumNativeFields = 4;
 
   // Create a test library.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars,
                                              native_field_lookup);
 
   // Create a native wrapper class with native fields.
   Dart_Handle result = Dart_CreateNativeWrapperClass(
       lib,
       Dart_NewString("NativeFieldsWrapper"),
       kNumNativeFields);
   EXPECT_VALID(result);
 
   // Load up a test script in it.
 
   // Invoke a function which returns an object of type NativeFields.
-  Dart_Handle retobj = Dart_InvokeStatic(lib,
-                                         Dart_NewString("NativeFieldsTest"),
-                                         Dart_NewString("testMain"),
-                                         0,
-                                         NULL);
+  Dart_Handle retobj = Dart_Invoke(lib, Dart_NewString("testMain"), 0, NULL);
   EXPECT_VALID(retobj);
 
   // Now access and set various instance fields of the returned object.
   TestNativeFields(retobj);
 }
 
 
 TEST_CASE(ImplicitNativeFieldAccess) {
   const char* kScriptChars =
       "#import('dart:nativewrappers');"
       "class NativeFields extends NativeFieldWrapperClass4 {\n"
       "  NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
       "  int fld0;\n"
       "  int fld1;\n"
       "  final int fld2;\n"
       "  static int fld3;\n"
       "  static final int fld4 = 10;\n"
       "}\n"
-      "class NativeFieldsTest {\n"
-      "  static NativeFields testMain() {\n"
-      "    NativeFields obj = new NativeFields(10, 20);\n"
-      "    return obj;\n"
-      "  }\n"
+      "NativeFields testMain() {\n"
+      "  NativeFields obj = new NativeFields(10, 20);\n"
+      "  return obj;\n"
       "}\n";
   // 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.
-  Dart_Handle retobj = Dart_InvokeStatic(lib,
-                                         Dart_NewString("NativeFieldsTest"),
-                                         Dart_NewString("testMain"),
-                                         0,
-                                         NULL);
+  Dart_Handle retobj = Dart_Invoke(lib, Dart_NewString("testMain"), 0, NULL);
   EXPECT_VALID(retobj);
 
   // Now access and set various instance fields of the returned object.
   TestNativeFields(retobj);
 }
 
 
 TEST_CASE(NegativeNativeFieldAccess) {
   const char* kScriptChars =
       "class NativeFields {\n"
       "  NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
       "  int fld1;\n"
       "  final int fld2;\n"
       "  static int fld3;\n"
       "  static final int fld4 = 10;\n"
       "}\n"
-      "class NativeFieldsTest {\n"
-      "  static NativeFields testMain1() {\n"
-      "    NativeFields obj = new NativeFields(10, 20);\n"
-      "    return obj;\n"
-      "  }\n"
-      "  static Function testMain2() {\n"
-      "    return function() {};\n"
-      "  }\n"
+      "NativeFields testMain1() {\n"
+      "  NativeFields obj = new NativeFields(10, 20);\n"
+      "  return obj;\n"
+      "}\n"
+      "Function testMain2() {\n"
+      "  return function() {};\n"
       "}\n";
   Dart_Handle result;
   DARTSCOPE_NOCHECKS(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_InvokeStatic(lib,
-                                         Dart_NewString("NativeFieldsTest"),
-                                         Dart_NewString("testMain1"),
-                                         0,
-                                         NULL);
+  Dart_Handle retobj = Dart_Invoke(lib, Dart_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
   // native fields in an instance of NativeFields.
   const int kNativeFld0 = 0;
   const int kNativeFld1 = 1;
   const int kNativeFld2 = 2;
   const int kNativeFld3 = 3;
   const int kNativeFld4 = 4;
   intptr_t value = 0;
   result = Dart_GetNativeInstanceField(retobj, kNativeFld4, &value);
   EXPECT(Dart_IsError(result));
   result = Dart_GetNativeInstanceField(retobj, kNativeFld0, &value);
   EXPECT(Dart_IsError(result));
   result = Dart_GetNativeInstanceField(retobj, kNativeFld1, &value);
   EXPECT(Dart_IsError(result));
   result = Dart_GetNativeInstanceField(retobj, kNativeFld2, &value);
   EXPECT(Dart_IsError(result));
   result = Dart_SetNativeInstanceField(retobj, kNativeFld4, 40);
   EXPECT(Dart_IsError(result));
   result = Dart_SetNativeInstanceField(retobj, kNativeFld3, 40);
   EXPECT(Dart_IsError(result));
   result = Dart_SetNativeInstanceField(retobj, kNativeFld0, 400);
   EXPECT(Dart_IsError(result));
 
   // Invoke a function which returns a closure object.
-  retobj = Dart_InvokeStatic(lib,
-                             Dart_NewString("NativeFieldsTest"),
-                             Dart_NewString("testMain2"),
-                             0,
-                             NULL);
+  retobj = Dart_Invoke(lib, Dart_NewString("testMain2"), 0, NULL);
   EXPECT_VALID(retobj);
+
   result = Dart_GetNativeInstanceField(retobj, kNativeFld4, &value);
   EXPECT(Dart_IsError(result));
   result = Dart_GetNativeInstanceField(retobj, kNativeFld0, &value);
   EXPECT(Dart_IsError(result));
   result = Dart_GetNativeInstanceField(retobj, kNativeFld1, &value);
   EXPECT(Dart_IsError(result));
   result = Dart_GetNativeInstanceField(retobj, kNativeFld2, &value);
   EXPECT(Dart_IsError(result));
   result = Dart_SetNativeInstanceField(retobj, kNativeFld4, 40);
   EXPECT(Dart_IsError(result));
   result = Dart_SetNativeInstanceField(retobj, kNativeFld3, 40);
   EXPECT(Dart_IsError(result));
   result = Dart_SetNativeInstanceField(retobj, kNativeFld0, 400);
   EXPECT(Dart_IsError(result));
 }
 
 
 TEST_CASE(GetStaticField_RunsInitializer) {
   const char* kScriptChars =
       "class TestClass  {\n"
       "  static final int fld1 = 7;\n"
       "  static int fld2 = 11;\n"
       "  static void testMain() {\n"
       "  }\n"
       "}\n";
   Dart_Handle result;
   // 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.
-  result = Dart_InvokeStatic(lib,
-                             Dart_NewString("TestClass"),
-                             Dart_NewString("testMain"),
-                             0,
-                             NULL);
-
   Dart_Handle cls = Dart_GetClass(lib, Dart_NewString("TestClass"));
   EXPECT_VALID(cls);
 
+  // Invoke a function which returns an object.
+  result = Dart_Invoke(cls, Dart_NewString("testMain"), 0, NULL);
+  EXPECT_VALID(result);
+
   // For uninitialized fields, the getter is returned
-  result = Dart_GetStaticField(cls, Dart_NewString("fld1"));
+  result = Dart_GetField(cls, Dart_NewString("fld1"));
   EXPECT_VALID(result);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(7, value);
 
-  result = Dart_GetStaticField(cls, Dart_NewString("fld2"));
+  result = Dart_GetField(cls, Dart_NewString("fld2"));
   EXPECT_VALID(result);
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(11, value);
 
   // Overwrite fld2
-  result = Dart_SetStaticField(cls,
-                               Dart_NewString("fld2"),
-                               Dart_NewInteger(13));
+  result = Dart_SetField(cls,
+                         Dart_NewString("fld2"),
+                         Dart_NewInteger(13));
   EXPECT_VALID(result);
 
   // We now get the new value for fld2, not the initializer
-  result = Dart_GetStaticField(cls, Dart_NewString("fld2"));
+  result = Dart_GetField(cls, Dart_NewString("fld2"));
   EXPECT_VALID(result);
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(13, value);
 }
 
 
-TEST_CASE(StaticFieldNotFound) {
-  const char* kScriptChars =
-      "class TestClass  {\n"
-      "  static void testMain() {\n"
-      "  }\n"
-      "}\n";
-  Dart_Handle result;
-  // Create a test library and Load up a test script in it.
-  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
-
-  // Invoke a function.
-  result = Dart_InvokeStatic(lib,
-                             Dart_NewString("TestClass"),
-                             Dart_NewString("testMain"),
-                             0,
-                             NULL);
-
-  Dart_Handle cls = Dart_GetClass(lib, Dart_NewString("TestClass"));
-  EXPECT_VALID(cls);
-
-  result = Dart_GetStaticField(cls, Dart_NewString("not_found"));
-  EXPECT(Dart_IsError(result));
-  EXPECT_STREQ("Specified field is not found in the class",
-               Dart_GetError(result));
-
-  result = Dart_SetStaticField(cls,
-                               Dart_NewString("not_found"),
-                               Dart_NewInteger(13));
-  EXPECT(Dart_IsError(result));
-  EXPECT_STREQ("Specified field is not found in the class",
-               Dart_GetError(result));
-}
-
-
 TEST_CASE(Invoke) {
   const char* kScriptChars =
       "class BaseMethods {\n"
       "  inheritedMethod(arg) => 'inherited $arg';\n"
       "  static nonInheritedMethod(arg) => 'noninherited $arg';\n"
       "}\n"
       "\n"
       "class Methods extends BaseMethods {\n"
       "  instanceMethod(arg) => 'instance $arg';\n"
       "  _instanceMethod(arg) => 'hidden instance $arg';\n"
@@ skipping 136 matching lines @@
                Dart_GetError(result));
 
   // Pass an error handle.  The error is contagious.
   args[0] = Api::NewError("myerror");
   result = Dart_Invoke(lib, Dart_NewString("test"), 1, args);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("myerror", Dart_GetError(result));
 }
 
 
-TEST_CASE(InvokeDynamic) {
-  const char* kScriptChars =
-      "class InvokeDynamic {\n"
-      "  InvokeDynamic(int i, int j) : fld1 = i, fld2 = j {}\n"
-      "  int method1(int i) { return i + fld1 + fld2 + fld4; }\n"
-      "  static int method2(int i) { return i + fld4; }\n"
-      "  int fld1;\n"
-      "  final int fld2;\n"
-      "  static final int fld4 = 10;\n"
-      "}\n"
-      "class InvokeDynamicTest {\n"
-      "  static InvokeDynamic testMain() {\n"
-      "    InvokeDynamic obj = new InvokeDynamic(10, 20);\n"
-      "    return obj;\n"
-      "  }\n"
-      "}\n";
-  Dart_Handle result;
-  DARTSCOPE_NOCHECKS(Isolate::Current());
+TEST_CASE(Invoke_Null) {
+  Dart_Handle result = Dart_Invoke(Dart_Null(),
+                                   Dart_NewString("toString"),
+                                   0,
+                                   NULL);
+  EXPECT_VALID(result);
+  EXPECT(Dart_IsString(result));
 
-  // Create a test library and Load up a test script in it.
-  Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
+  const char* value = "";
+  EXPECT_VALID(Dart_StringToCString(result, &value));
+  EXPECT_STREQ("null", value);
 
-  // Invoke a function which returns an object of type InvokeDynamic.
-  Dart_Handle retobj = Dart_InvokeStatic(lib,
-                                         Dart_NewString("InvokeDynamicTest"),
-                                         Dart_NewString("testMain"),
-                                         0,
-                                         NULL);
-  EXPECT_VALID(retobj);
-
-
-  // Now invoke a dynamic method and check the result.
-  Dart_Handle dart_arguments[1];
-  dart_arguments[0] = Dart_NewInteger(1);
-  result = Dart_InvokeDynamic(retobj,
-                              Dart_NewString("method1"),
-                              1,
-                              dart_arguments);
-  EXPECT_VALID(result);
-  EXPECT(Dart_IsInteger(result));
-  int64_t value = 0;
-  result = Dart_IntegerToInt64(result, &value);
-  EXPECT_EQ(41, value);
-
-  result = Dart_InvokeDynamic(retobj, Dart_NewString("method2"), 0, NULL);
-  EXPECT(Dart_IsError(result));
-
-  result = Dart_InvokeDynamic(retobj, Dart_NewString("method1"), 0, NULL);
-  EXPECT(Dart_IsError(result));
+  // Should throw a NullPointerException. Disabled due to bug 5415268.
+  /*
+    Dart_Handle function_name2 = Dart_NewString("NoNoNo");
+    result = Dart_Invoke(null_receiver,
+    function_name2,
+    number_of_arguments,
+    dart_arguments);
+    EXPECT(Dart_IsError(result));
+    EXPECT(Dart_ErrorHasException(result)); */
 }
 
 
+TEST_CASE(Invoke_CrossLibrary) {
+  const char* kLibrary1Chars =
+      "#library('library1_name');\n"
+      "void local() {}\n"
+      "void _local() {}\n";
+  const char* kLibrary2Chars =
+      "#library('library2_name');\n"
+      "void imported() {}\n"
+      "void _imported() {}\n";
+
+  // Load lib1
+  Dart_Handle url = Dart_NewString("library1_url");
+  Dart_Handle source = Dart_NewString(kLibrary1Chars);
+  Dart_Handle import_map = Dart_NewList(0);
+  Dart_Handle lib1 = Dart_LoadLibrary(url, source, import_map);
+  EXPECT_VALID(lib1);
+
+  // Load lib2
+  url = Dart_NewString("library2_url");
+  source = Dart_NewString(kLibrary2Chars);
+  Dart_Handle lib2 = Dart_LoadLibrary(url, source, import_map);
+  EXPECT_VALID(lib2);
+
+  // Import lib2 from lib1
+  Dart_Handle result = Dart_LibraryImportLibrary(lib1, lib2);
+  EXPECT_VALID(result);
+
+  // We can invoke both private and non-private local functions.
+  EXPECT_VALID(Dart_Invoke(lib1, Dart_NewString("local"), 0, NULL));
+  EXPECT_VALID(Dart_Invoke(lib1, Dart_NewString("_local"), 0, NULL));
+
+  // We can only invoke non-private imported functions.
+  EXPECT_VALID(Dart_Invoke(lib1, Dart_NewString("imported"), 0, NULL));
+  EXPECT_ERROR(Dart_Invoke(lib1, Dart_NewString("_imported"), 0, NULL),
+               "did not find top-level function '_imported'");
+}
+
+
 TEST_CASE(InvokeClosure) {
   const char* kScriptChars =
       "class InvokeClosure {\n"
       "  InvokeClosure(int i, int j) : fld1 = i, fld2 = j {}\n"
       "  Function method1(int i) {\n"
       "    f(int j) => j + i + fld1 + fld2 + fld4; \n"
       "    return f;\n"
       "  }\n"
       "  static Function method2(int i) {\n"
       "    n(int j) => true + i + fld4; \n"
       "    return n;\n"
       "  }\n"
       "  int fld1;\n"
       "  final int fld2;\n"
       "  static final int fld4 = 10;\n"
       "}\n"
-      "class InvokeClosureTest {\n"
-      "  static Function testMain1() {\n"
-      "    InvokeClosure obj = new InvokeClosure(10, 20);\n"
-      "    return obj.method1(10);\n"
-      "  }\n"
-      "  static Function testMain2() {\n"
-      "    return InvokeClosure.method2(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());
 
   // 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_InvokeStatic(lib,
-                                         Dart_NewString("InvokeClosureTest"),
-                                         Dart_NewString("testMain1"),
-                                         0,
-                                         NULL);
+  Dart_Handle retobj = Dart_Invoke(lib, Dart_NewString("testMain1"), 0, NULL);
   EXPECT_VALID(retobj);
 
   EXPECT(Dart_IsClosure(retobj));
   EXPECT(!Dart_IsClosure(Dart_NewInteger(101)));
 
   // Now invoke the closure and check the result.
   Dart_Handle dart_arguments[1];
   dart_arguments[0] = Dart_NewInteger(1);
   result = Dart_InvokeClosure(retobj, 1, dart_arguments);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(51, value);
 
   // Invoke closure with wrong number of args, should result in exception.
   result = Dart_InvokeClosure(retobj, 0, NULL);
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_ErrorHasException(result));
 
   // Invoke a function which returns a closure.
-  retobj = Dart_InvokeStatic(lib,
-                             Dart_NewString("InvokeClosureTest"),
-                             Dart_NewString("testMain2"),
-                             0,
-                             NULL);
+  retobj = Dart_Invoke(lib, Dart_NewString("testMain2"), 0, NULL);
   EXPECT_VALID(retobj);
 
   EXPECT(Dart_IsClosure(retobj));
   EXPECT(!Dart_IsClosure(Dart_NewString("abcdef")));
 
   // Now invoke the closure and check the result (should be an exception).
   dart_arguments[0] = Dart_NewInteger(1);
   result = Dart_InvokeClosure(retobj, 1, dart_arguments);
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_ErrorHasException(result));
@@ skipping 16 matching lines @@
 TEST_CASE(ThrowException) {
   const char* kScriptChars =
       "class ThrowException {\n"
       "  ThrowException(int i) : fld1 = i {}\n"
       "  int method1(int i) native \"ThrowException_native\";"
       "  int method2() {\n"
       "     try { method1(10); } catch(var a) { return 5; } return 10;\n"
       "  }\n"
       "  int fld1;\n"
       "}\n"
-      "class ThrowExceptionTest {\n"
-      "  static ThrowException testMain() {\n"
-      "    ThrowException obj = new ThrowException(10);\n"
-      "    return obj;\n"
-      "  }\n"
+      "ThrowException testMain() {\n"
+      "  ThrowException obj = new ThrowException(10);\n"
+      "  return obj;\n"
       "}\n";
   Dart_Handle result;
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
   intptr_t size = state->ZoneSizeInBytes();
   Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
 
   // Load up a test script which extends the native wrapper class.
   Dart_Handle lib = TestCase::LoadTestScript(
       kScriptChars,
       reinterpret_cast<Dart_NativeEntryResolver>(native_lookup));
 
   // Invoke a function which returns an object of type ThrowException.
-  Dart_Handle retobj = Dart_InvokeStatic(lib,
-                                         Dart_NewString("ThrowExceptionTest"),
-                                         Dart_NewString("testMain"),
-                                         0,
-                                         NULL);
+  Dart_Handle retobj = Dart_Invoke(lib, Dart_NewString("testMain"), 0, NULL);
   EXPECT_VALID(retobj);
 
   // Throwing an exception here should result in an error.
   result = Dart_ThrowException(retobj);
   EXPECT(Dart_IsError(result));
 
   // Now invoke method2 which invokes a natve method where it is
   // ok to throw an exception, check the result which would indicate
   // if an exception was thrown or not.
-  result = Dart_InvokeDynamic(retobj, Dart_NewString("method2"), 0, NULL);
+  result = Dart_Invoke(retobj, Dart_NewString("method2"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_EQ(5, value);
 
   Dart_ExitScope();  // Exit the Dart API scope.
   EXPECT_EQ(size, state->ZoneSizeInBytes());
 }
 
 
 void NativeArgumentCounter(Dart_NativeArguments args) {
   Dart_EnterScope();
   int count = Dart_GetNativeArgumentCount(args);
   Dart_SetReturnValue(args, Dart_NewInteger(count));
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction gnac_lookup(Dart_Handle name, int argument_count) {
   return reinterpret_cast<Dart_NativeFunction>(&NativeArgumentCounter);
 }
 
 
 TEST_CASE(GetNativeArgumentCount) {
   const char* kScriptChars =
       "class MyObject {"
       "  int method1(int i, int j) native 'Name_Does_Not_Matter';"
       "}"
-      "class Test {"
-      "  static testMain() {"
-      "    MyObject obj = new MyObject();"
-      "    return obj.method1(77, 125);"
-      "  }"
+      "testMain() {"
+      "  MyObject obj = new MyObject();"
+      "  return obj.method1(77, 125);"
       "}";
 
   Dart_Handle lib = TestCase::LoadTestScript(
       kScriptChars,
       reinterpret_cast<Dart_NativeEntryResolver>(gnac_lookup));
 
-  Dart_Handle result = Dart_InvokeStatic(lib,
-                                         Dart_NewString("Test"),
-                                         Dart_NewString("testMain"),
-                                         0,
-                                         NULL);
+  Dart_Handle result = Dart_Invoke(lib, Dart_NewString("testMain"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
 
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(3, value);
 }
 
 
@@ skipping 24 matching lines @@
       "class InstanceOfTest {\n"
       "  InstanceOfTest() {}\n"
       "  static InstanceOfTest testMain() {\n"
       "    return new InstanceOfTest();\n"
       "  }\n"
       "}\n";
   Dart_Handle result;
   // 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 InstanceOf..
-  Dart_Handle instanceOfTestObj =
-      Dart_InvokeStatic(lib,
-                        Dart_NewString("InstanceOfTest"),
-                        Dart_NewString("testMain"),
-                        0,
-                        NULL);
-  EXPECT_VALID(instanceOfTestObj);
-
   // Fetch InstanceOfTest class.
   Dart_Handle cls = Dart_GetClass(lib, Dart_NewString("InstanceOfTest"));
   EXPECT_VALID(cls);
 
+  // Invoke a function which returns an object of type InstanceOf..
+  Dart_Handle instanceOfTestObj =
+      Dart_Invoke(cls, Dart_NewString("testMain"), 0, NULL);
+  EXPECT_VALID(instanceOfTestObj);
+
   // Now check instanceOfTestObj reported as an instance of
   // InstanceOfTest class.
   bool is_instance = false;
   result = Dart_ObjectIsType(instanceOfTestObj, cls, &is_instance);
   EXPECT_VALID(result);
   EXPECT(is_instance);
 
   // Fetch OtherClass and check if instanceOfTestObj is instance of it.
   Dart_Handle otherClass = Dart_GetClass(lib, Dart_NewString("OtherClass"));
   EXPECT_VALID(otherClass);
@@ skipping 10 matching lines @@
 
   result = Dart_ObjectIsType(Dart_NewInteger(42), otherClass, &is_instance);
   EXPECT_VALID(result);
   EXPECT(!is_instance);
 
   result = Dart_ObjectIsType(Dart_NewBoolean(true), otherClass, &is_instance);
   EXPECT_VALID(result);
   EXPECT(!is_instance);
 
   // Check that null is not an instance of InstanceOfTest class.
-  Dart_Handle null = Dart_InvokeStatic(lib,
-                                       Dart_NewString("OtherClass"),
-                                       Dart_NewString("returnNull"),
-                                       0,
-                                       NULL);
+  Dart_Handle null = Dart_Invoke(otherClass,
+                                 Dart_NewString("returnNull"),
+                                 0,
+                                 NULL);
   EXPECT_VALID(null);
 
   result = Dart_ObjectIsType(null, otherClass, &is_instance);
   EXPECT_VALID(result);
   EXPECT(!is_instance);
 
   // Check that error is returned if null is passed as a class argument.
   result = Dart_ObjectIsType(null, null, &is_instance);
   EXPECT(Dart_IsError(result));
 }
 
 
-TEST_CASE(NullReceiver) {
-  Isolate* isolate = Isolate::Current();
-  DARTSCOPE_NOCHECKS(isolate);
-
-  Dart_Handle function_name = Dart_NewString("toString");
-  const int number_of_arguments = 0;
-  Dart_Handle result = Dart_InvokeDynamic(Dart_Null(),
-                                          function_name,
-                                          number_of_arguments,
-                                          NULL);
-  EXPECT_VALID(result);
-  EXPECT(Dart_IsString(result));
-
-  // Should throw a NullPointerException. Disabled due to bug 5415268.
-  /*
-    Dart_Handle function_name2 = Dart_NewString("NoNoNo");
-    result = Dart_InvokeDynamic(null_receiver,
-    function_name2,
-    number_of_arguments,
-    dart_arguments);
-    EXPECT(Dart_IsError(result));
-    EXPECT(Dart_ErrorHasException(result)); */
-}
-
-
 static Dart_Handle library_handler(Dart_LibraryTag tag,
                                    Dart_Handle library,
                                    Dart_Handle url,
                                    Dart_Handle import_url_map) {
   if (tag == kCanonicalizeUrl) {
     return url;
   }
   return Api::Success(Isolate::Current());
 }
 
@@ skipping 35 matching lines @@
       Dart_GetError(result));
 
   result = Dart_LoadScript(url, error, library_handler, import_map);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("incoming error", Dart_GetError(result));
 
   // Load a script successfully.
   result = Dart_LoadScript(url, source, library_handler, import_map);
   EXPECT_VALID(result);
 
-  result = Dart_InvokeStatic(result,
-                             Dart_NewString(""),
-                             Dart_NewString("main"),
-                             0,
-                             NULL);
+  result = Dart_Invoke(result, Dart_NewString("main"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   int64_t value = 0;
   EXPECT_VALID(Dart_IntegerToInt64(result, &value));
   EXPECT_EQ(12345, value);
 
   // Further calls to LoadScript are errors.
   result = Dart_LoadScript(url, source, library_handler, import_map);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("Dart_LoadScript: "
@@ skipping 456 matching lines @@
   Dart_Handle error = Dart_Error("incoming error");
   Dart_Handle result;
 
   // Load a test script.
   Dart_Handle url = Dart_NewString(TestCase::url());
   Dart_Handle source = Dart_NewString(kScriptChars);
   Dart_Handle import_map = Dart_NewList(0);
   Dart_Handle lib = Dart_LoadScript(url, source, library_handler, import_map);
   EXPECT_VALID(lib);
   EXPECT(Dart_IsLibrary(lib));
+  Dart_Handle cls = Dart_GetClass(lib, Dart_NewString("Test"));
+  EXPECT_VALID(cls);
 
   result = Dart_SetNativeResolver(Dart_Null(), &MyNativeResolver1);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ(
       "Dart_SetNativeResolver expects argument 'library' to be non-null.",
       Dart_GetError(result));
 
   result = Dart_SetNativeResolver(Dart_True(), &MyNativeResolver1);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("Dart_SetNativeResolver expects argument 'library' to be of "
                "type Library.",
                Dart_GetError(result));
 
   result = Dart_SetNativeResolver(error, &MyNativeResolver1);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("incoming error", Dart_GetError(result));
 
   result = Dart_SetNativeResolver(lib, &MyNativeResolver1);
   EXPECT_VALID(result);
 
   // Call a function and make sure native resolution works.
-  result = Dart_InvokeStatic(lib,
-                             Dart_NewString("Test"),
-                             Dart_NewString("foo"),
-                             0,
-                             NULL);
+  result = Dart_Invoke(cls, Dart_NewString("foo"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   int64_t value = 0;
   EXPECT_VALID(Dart_IntegerToInt64(result, &value));
   EXPECT_EQ(654321, value);
 
   // A second call succeeds.
   result = Dart_SetNativeResolver(lib, &MyNativeResolver2);
   EXPECT_VALID(result);
 
   // 'foo' has already been resolved so gets the old value.
-  result = Dart_InvokeStatic(lib,
-                             Dart_NewString("Test"),
-                             Dart_NewString("foo"),
-                             0,
-                             NULL);
+  result = Dart_Invoke(cls, Dart_NewString("foo"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   value = 0;
   EXPECT_VALID(Dart_IntegerToInt64(result, &value));
   EXPECT_EQ(654321, value);
 
   // 'bar' has not yet been resolved so gets the new value.
-  result = Dart_InvokeStatic(lib,
-                             Dart_NewString("Test"),
-                             Dart_NewString("bar"),
-                             0,
-                             NULL);
+  result = Dart_Invoke(cls, Dart_NewString("bar"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   value = 0;
   EXPECT_VALID(Dart_IntegerToInt64(result, &value));
   EXPECT_EQ(123456, value);
 
   // A NULL resolver is okay, but resolution will fail.
   result = Dart_SetNativeResolver(lib, NULL);
   EXPECT_VALID(result);
 
-  result = Dart_InvokeStatic(lib,
-                             Dart_NewString("Test"),
-                             Dart_NewString("baz"),
-                             0,
-                             NULL);
-  EXPECT(Dart_IsError(result));
-  EXPECT(strstr(Dart_GetError(result),
-                "native function 'SomeNativeFunction3' cannot be found"));
+  EXPECT_ERROR(Dart_Invoke(cls, Dart_NewString("baz"), 0, NULL),
+               "native function 'SomeNativeFunction3' cannot be found");
 }
 
 
 TEST_CASE(ImportLibrary1) {
   const char* kScriptChars =
       "#import('library1.dart');"
       "#import('library2.dart');"
       "var foo;  // library2 defines foo, so should be error."
       "main() {}";
   const char* kLibrary1Chars =
@@ skipping 10 matching lines @@
   result = Dart_LoadScript(url, source, library_handler, Dart_Null());
 
   url = Dart_NewString("library1.dart");
   source = Dart_NewString(kLibrary1Chars);
   Dart_LoadLibrary(url, source, Dart_Null());
 
   url = Dart_NewString("library2.dart");
   source = Dart_NewString(kLibrary2Chars);
   Dart_LoadLibrary(url, source, Dart_Null());
 
-  result = Dart_InvokeStatic(result,
-                             Dart_NewString(""),
-                             Dart_NewString("main"),
-                             0,
-                             NULL);
+  result = Dart_Invoke(result, Dart_NewString("main"), 0, NULL);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("Duplicate definition : 'foo' is defined in"
                " 'library2.dart' and 'dart:test-lib'\n",
                Dart_GetError(result));
 }
 
 
 TEST_CASE(ImportLibrary2) {
   const char* kScriptChars =
       "#import('library1.dart');"
@@ skipping 15 matching lines @@
   result = Dart_LoadScript(url, source, library_handler, import_map);
 
   url = Dart_NewString("library1.dart");
   source = Dart_NewString(kLibrary1Chars);
   Dart_LoadLibrary(url, source, import_map);
 
   url = Dart_NewString("library2.dart");
   source = Dart_NewString(kLibrary2Chars);
   Dart_LoadLibrary(url, source, import_map);
 
-  result = Dart_InvokeStatic(result,
-                             Dart_NewString(""),
-                             Dart_NewString("main"),
-                             0,
-                             NULL);
+  result = Dart_Invoke(result, Dart_NewString("main"), 0, NULL);
   EXPECT_VALID(result);
 }
 
 
 TEST_CASE(ImportLibrary3) {
   const char* kScriptChars =
       "#import('library2.dart');"
       "#import('library1.dart');"
       "var foo_top = 10;  // foo has dup def. So should be an error."
       "main() {}";
@@ skipping 12 matching lines @@
   result = Dart_LoadScript(url, source, library_handler, import_map);
 
   url = Dart_NewString("library2.dart");
   source = Dart_NewString(kLibrary2Chars);
   Dart_LoadLibrary(url, source, import_map);
 
   url = Dart_NewString("library1.dart");
   source = Dart_NewString(kLibrary1Chars);
   Dart_LoadLibrary(url, source, import_map);
 
-  result = Dart_InvokeStatic(result,
-                             Dart_NewString(""),
-                             Dart_NewString("main"),
-                             0,
-                             NULL);
+  result = Dart_Invoke(result, Dart_NewString("main"), 0, NULL);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("Duplicate definition : 'foo' is defined in"
                " 'library1.dart' and 'library2.dart'\n",
                Dart_GetError(result));
 }
 
 
 TEST_CASE(ImportLibrary4) {
   const char* kScriptChars =
       "#import('libraryA.dart');"
@@ skipping 50 matching lines @@
   Dart_LoadLibrary(url, source, import_map);
 
   url = Dart_NewString("libraryF.dart");
   source = Dart_NewString(kLibraryFChars);
   Dart_LoadLibrary(url, source, import_map);
 
   url = Dart_NewString("libraryE.dart");
   source = Dart_NewString(kLibraryEChars);
   Dart_LoadLibrary(url, source, import_map);
 
-  result = Dart_InvokeStatic(result,
-                             Dart_NewString(""),
-                             Dart_NewString("main"),
-                             0,
-                             NULL);
+  result = Dart_Invoke(result, Dart_NewString("main"), 0, NULL);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("Duplicate definition : 'fooC' is defined in"
                " 'libraryF.dart' and 'libraryC.dart'\n",
                Dart_GetError(result));
 }
 
 
 TEST_CASE(ImportLibrary5) {
   const char* kScriptChars =
       "#import('lib.dart');"
@@ skipping 11 matching lines @@
   // Create a test library and Load up a test script in it.
   Dart_Handle url = Dart_NewString(TestCase::url());
   Dart_Handle source = Dart_NewString(kScriptChars);
   Dart_Handle import_map = Dart_NewList(0);
   result = Dart_LoadScript(url, source, library_handler, import_map);
 
   url = Dart_NewString("lib.dart");
   source = Dart_NewString(kLibraryChars);
   Dart_LoadLibrary(url, source, import_map);
 
-  result = Dart_InvokeStatic(result,
-                             Dart_NewString(""),
-                             Dart_NewString("main"),
-                             0,
-                             NULL);
+  result = Dart_Invoke(result, Dart_NewString("main"), 0, NULL);
   EXPECT_VALID(result);
 }
 
 
 void NewNativePort_send123(Dart_Port dest_port_id,
                            Dart_Port reply_port_id,
                            Dart_CObject *message) {
   // Gets a null message.
   EXPECT_NOTNULL(message);
   EXPECT_EQ(Dart_CObject::kNull, message->type);
@@ skipping 48 matching lines @@
       Dart_NewNativePort("Port321", NewNativePort_send321, true);
 
   Dart_Handle send_port1 = Dart_NewSendPort(port_id1);
   EXPECT_VALID(send_port1);
   Dart_Handle send_port2 = Dart_NewSendPort(port_id2);
   EXPECT_VALID(send_port2);
 
   // Test first port.
   Dart_Handle dart_args[1];
   dart_args[0] = send_port1;
-  Dart_Handle result = Dart_InvokeStatic(lib,
-                                         Dart_NewString(""),
-                                         Dart_NewString("callPort"),
-                                         1,
-                                         dart_args);
+  Dart_Handle result =
+      Dart_Invoke(lib, Dart_NewString("callPort"), 1, dart_args);
   EXPECT_VALID(result);
   result = Dart_RunLoop();
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_ErrorHasException(result));
   EXPECT_SUBSTRING("Exception: 123\n", Dart_GetError(result));
 
   // result second port.
   dart_args[0] = send_port2;
-  result = Dart_InvokeStatic(lib,
-                             Dart_NewString(""),
-                             Dart_NewString("callPort"),
-                             1,
-                             dart_args);
+  result = Dart_Invoke(lib, Dart_NewString("callPort"), 1, dart_args);
   EXPECT_VALID(result);
   result = Dart_RunLoop();
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_ErrorHasException(result));
   EXPECT_SUBSTRING("Exception: 321\n", Dart_GetError(result));
 
   Dart_ExitScope();
 
   // Delete the native ports.
   EXPECT(Dart_CloseNativePort(port_id1));
@@ skipping 56 matching lines @@
   RunLoopTestCallback(NULL, NULL, NULL);
 
   Dart_EnterScope();
   Dart_Handle lib = Dart_LookupLibrary(Dart_NewString(TestCase::url()));
   EXPECT_VALID(lib);
 
   Dart_Handle result;
   Dart_Handle args[2];
   args[0] = (throw_exception_child ? Dart_True() : Dart_False());
   args[1] = (throw_exception_parent ? Dart_True() : Dart_False());
-  result = Dart_InvokeStatic(lib,
-                             Dart_NewString(""),
-                             Dart_NewString("main"),
-                             2,
-                             args);
+  result = Dart_Invoke(lib, Dart_NewString("main"), 2, args);
   EXPECT_VALID(result);
   result = Dart_RunLoop();
   if (throw_exception_parent) {
-    EXPECT(Dart_IsError(result));
-    // TODO(turnidge): Once EXPECT_SUBSTRING is submitted use it here.
+    EXPECT_ERROR(result, "Exception: MakeParentExit");
   } else {
     EXPECT_VALID(result);
   }
 
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 
   Isolate::SetCreateCallback(saved);
 }
 
@@ skipping 65 matching lines @@
     lib = Dart_LoadScript(url, source, TestCase::library_handler, import_map);
     EXPECT_VALID(lib);
     Dart_Handle result = Dart_SetNativeResolver(
         lib, &IsolateInterruptTestNativeLookup);
     DART_CHECK_VALID(result);
 
     sync->Notify();
     sync->Exit();
   }
 
-  Dart_Handle result = Dart_InvokeStatic(lib,
-                                         Dart_NewString(""),
-                                         Dart_NewString("main"),
-                                         0,
-                                         NULL);
+  Dart_Handle result = Dart_Invoke(lib, Dart_NewString("main"), 0, NULL);
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_ErrorHasException(result));
   EXPECT_SUBSTRING("Unhandled exception:\nfoo\n",
                    Dart_GetError(result));
 
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 
   // Tell the other thread that we are done (don't use MonitorLocker
   // as there is no current isolate any more).
@@ skipping 181 matching lines @@
   EXPECT_VALID(result);
   EXPECT(Dart_IsDouble(result));
   double out;
   result = Dart_DoubleValue(result, &out);
   fprintf(stderr, "Benchmark_UseDartApi: %f us per iteration\n", out);
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart