Change the library directive syntax in the VM unit tests,

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 2629 matching lines @@
       "\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"
+      "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"
@@ skipping 283 matching lines @@
 
   // 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');"
+      "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 const int fld4 = 10;\n"
       "}\n"
       "NativeFields testMain() {\n"
       "  NativeFields obj = new NativeFields(10, 20);\n"
       "  return obj;\n"
@@ skipping 21 matching lines @@
   intptr_t header_size = sizeof(RawObject);
   EXPECT_EQ(Utils::RoundUp(((1 + 2) * kWordSize) + header_size,
                            kObjectAlignment),
             cls.instance_size());
   EXPECT_EQ(kNumNativeFields, cls.num_native_fields());
 }
 
 
 TEST_CASE(InjectNativeFields4) {
   const char* kScriptChars =
-      "#import('dart:nativewrappers');"
+      "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 const int fld4 = 10;\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_Invoke(lib, 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: "
+      "'dart:test-lib': Error: line 1 pos 36: "
       "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));
 }
 
 
 TEST_CASE(InjectNativeFieldsSuperClass) {
   const char* kScriptChars =
-      "#import('dart:nativewrappers');"
+      "import 'dart:nativewrappers';"
       "class NativeFieldsSuper extends NativeFieldWrapperClass1 {\n"
       "  NativeFieldsSuper() : fld1 = 42 {}\n"
       "  int fld1;\n"
       "}\n"
       "class NativeFields extends NativeFieldsSuper {\n"
       "  fld() => fld1;\n"
       "}\n"
       "int testMain() {\n"
       "  NativeFields obj = new NativeFields();\n"
       "  return obj.fld();\n"
@@ skipping 139 matching lines @@
   EXPECT_STREQ("myerror", Dart_GetError(result));
 
   result = Dart_SetNativeInstanceField(error, 0, 1);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("myerror", Dart_GetError(result));
 }
 
 
 TEST_CASE(ImplicitNativeFieldAccess) {
   const char* kScriptChars =
-      "#import('dart:nativewrappers');"
+      "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 const int fld4 = 10;\n"
       "}\n"
       "NativeFields testMain() {\n"
       "  NativeFields obj = new NativeFields(10, 20);\n"
@@ skipping 605 matching lines @@
     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"
+      "library library1_name;\n"
       "void local() {}\n"
       "void _local() {}\n";
   const char* kLibrary2Chars =
-      "#library('library2_name');\n"
+      "library library2_name;\n"
       "void imported() {}\n"
       "void _imported() {}\n";
 
   // Load lib1
   Dart_Handle url = NewString("library1_url");
   Dart_Handle source = NewString(kLibrary1Chars);
   Dart_Handle lib1 = Dart_LoadLibrary(url, source);
   EXPECT_VALID(lib1);
 
   // Load lib2
@@ skipping 1279 matching lines @@
   Dart_Handle result = Dart_SetLibraryTagHandler(import_library_handler);
   EXPECT_VALID(result);
   result = Dart_LoadScript(url, source);
   EXPECT(Dart_IsError(result));
   EXPECT(strstr(Dart_GetError(result), "unexpected token ')'"));
 }
 
 
 TEST_CASE(LookupLibrary) {
   const char* kScriptChars =
-      "#import('library1.dart');"
+      "import 'library1_dart';"
       "main() {}";
   const char* kLibrary1Chars =
-      "#library('library1.dart');"
-      "#import('library2.dart');";
+      "library library1_dart;"
+      "import 'library2_dart';";
 
   // Create a test library and Load up a test script in it.
   Dart_Handle url = NewString(TestCase::url());
   Dart_Handle source = NewString(kScriptChars);
   Dart_Handle result = Dart_SetLibraryTagHandler(library_handler);
   EXPECT_VALID(result);
   result = Dart_LoadScript(url, source);
   EXPECT_VALID(result);
 
-  url = NewString("library1.dart");
+  url = NewString("library1_dart");
   source = NewString(kLibrary1Chars);
   result = Dart_LoadLibrary(url, source);
   EXPECT_VALID(result);
 
   result = Dart_LookupLibrary(url);
   EXPECT_VALID(result);
 
   result = Dart_LookupLibrary(Dart_Null());
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("Dart_LookupLibrary expects argument 'url' to be non-null.",
@@ skipping 12 matching lines @@
   url = NewString("noodles.dart");
   result = Dart_LookupLibrary(url);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("Dart_LookupLibrary: library 'noodles.dart' not found.",
                Dart_GetError(result));
 }
 
 
 TEST_CASE(LibraryName) {
   const char* kLibrary1Chars =
-      "#library('library1_name');";
+      "library library1_name;";
   Dart_Handle url = NewString("library1_url");
   Dart_Handle source = NewString(kLibrary1Chars);
   Dart_Handle lib = Dart_LoadLibrary(url, source);
   Dart_Handle error = Dart_Error("incoming error");
   EXPECT_VALID(lib);
 
   Dart_Handle result = Dart_LibraryName(Dart_Null());
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("Dart_LibraryName expects argument 'library' to be non-null.",
                Dart_GetError(result));
@@ skipping 12 matching lines @@
   EXPECT_VALID(result);
   EXPECT(Dart_IsString(result));
   const char* cstr = NULL;
   EXPECT_VALID(Dart_StringToCString(result, &cstr));
   EXPECT_STREQ("library1_name", cstr);
 }
 
 
 TEST_CASE(LibraryUrl) {
   const char* kLibrary1Chars =
-      "#library('library1_name');";
+      "library library1_name;";
   Dart_Handle url = NewString("library1_url");
   Dart_Handle source = NewString(kLibrary1Chars);
   Dart_Handle lib = Dart_LoadLibrary(url, source);
   Dart_Handle error = Dart_Error("incoming error");
   EXPECT_VALID(lib);
 
   Dart_Handle result = Dart_LibraryUrl(Dart_Null());
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("Dart_LibraryUrl expects argument 'library' to be non-null.",
                Dart_GetError(result));
@@ skipping 12 matching lines @@
   EXPECT_VALID(result);
   EXPECT(Dart_IsString(result));
   const char* cstr = NULL;
   EXPECT_VALID(Dart_StringToCString(result, &cstr));
   EXPECT_STREQ("library1_url", cstr);
 }
 
 
 TEST_CASE(LibraryGetClassNames) {
   const char* kLibraryChars =
-      "#library('library_name');\n"
+      "library library_name;\n"
       "\n"
       "class A {}\n"
       "class B {}\n"
       "interface C {}\n"
       "class _A {}\n"
       "class _B {}\n"
       "interface _C {}\n"
       "\n"
       "_compare(String a, String b) => a.compareTo(b);\n"
       "sort(list) => list.sort(_compare);\n";
@@ skipping 16 matching lines @@
   Dart_Handle list_string = Dart_ToString(list);
   EXPECT_VALID(list_string);
   const char* list_cstr = "";
   EXPECT_VALID(Dart_StringToCString(list_string, &list_cstr));
   EXPECT_STREQ("[A, B, C, _A, _B, _C]", list_cstr);
 }
 
 
 TEST_CASE(GetFunctionNames) {
   const char* kLibraryChars =
-      "#library('library_name');\n"
+      "library library_name;\n"
       "\n"
       "void A() {}\n"
       "get B => 11;\n"
       "set C(x) { }\n"
       "var D;\n"
       "void _A() {}\n"
       "get _B => 11;\n"
       "set _C(x) { }\n"
       "var _D;\n"
       "\n"
@@ skipping 49 matching lines @@
   list_string = Dart_ToString(list);
   EXPECT_VALID(list_string);
   list_cstr = "";
   EXPECT_VALID(Dart_StringToCString(list_string, &list_cstr));
   EXPECT_STREQ("[A2, B2, C2=, MyClass, _A2, _B2, _C2=]", list_cstr);
 }
 
 
 TEST_CASE(GetVariableNames) {
   const char* kLibraryChars =
-      "#library('library_name');\n"
+      "library library_name;\n"
       "\n"
       "var A;\n"
       "get B => 12;\n"
       "set C(x) { }\n"
       "D(x) => (x + 1);\n"
       "var _A;\n"
       "get _B => 12;\n"
       "set _C(x) { }\n"
       "_D(x) => (x + 1);\n"
       "\n"
@@ skipping 44 matching lines @@
   list_string = Dart_ToString(list);
   EXPECT_VALID(list_string);
   list_cstr = "";
   EXPECT_VALID(Dart_StringToCString(list_string, &list_cstr));
   EXPECT_STREQ("[A2, _A2]", list_cstr);
 }
 
 
 TEST_CASE(LibraryImportLibrary) {
   const char* kLibrary1Chars =
-      "#library('library1_name');";
+      "library library1_name;";
   const char* kLibrary2Chars =
-      "#library('library2_name');";
+      "library library2_name;";
   Dart_Handle error = Dart_Error("incoming error");
   Dart_Handle result;
 
   Dart_Handle url = NewString("library1_url");
   Dart_Handle source = NewString(kLibrary1Chars);
   Dart_Handle lib1 = Dart_LoadLibrary(url, source);
   EXPECT_VALID(lib1);
 
   url = NewString("library2_url");
   source = NewString(kLibrary2Chars);
@@ skipping 32 matching lines @@
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("incoming error", Dart_GetError(result));
 
   result = Dart_LibraryImportLibrary(lib1, lib2, Dart_Null());
   EXPECT_VALID(result);
 }
 
 
 TEST_CASE(ImportLibraryWithPrefix) {
   const char* kLibrary1Chars =
-      "#library('library1_name');"
+      "library library1_name;"
       "int bar() => 42;";
   Dart_Handle url1 = NewString("library1_url");
   Dart_Handle source1 = NewString(kLibrary1Chars);
   Dart_Handle lib1 = Dart_LoadLibrary(url1, source1);
   EXPECT_VALID(lib1);
   EXPECT(Dart_IsLibrary(lib1));
 
   const char* kLibrary2Chars =
-      "#library('library2_name');"
+      "library library2_name;"
       "int foobar() => foo.bar();";
   Dart_Handle url2 = NewString("library2_url");
   Dart_Handle source2 = NewString(kLibrary2Chars);
   Dart_Handle lib2 = Dart_LoadLibrary(url2, source2);
   EXPECT_VALID(lib2);
   EXPECT(Dart_IsLibrary(lib2));
 
   Dart_Handle prefix = NewString("foo");
   Dart_Handle result = Dart_LibraryImportLibrary(lib2, lib1, prefix);
   EXPECT_VALID(result);
@@ skipping 11 matching lines @@
   EXPECT(Dart_IsInteger(result));
   int64_t value = 0;
   EXPECT_VALID(Dart_IntegerToInt64(result, &value));
   EXPECT_EQ(42, value);
 }
 
 
 
 TEST_CASE(LoadLibrary) {
   const char* kLibrary1Chars =
-      "#library('library1_name');";
+      "library library1_name;";
   Dart_Handle error = Dart_Error("incoming error");
   Dart_Handle result;
 
   Dart_Handle url = NewString("library1_url");
   Dart_Handle source = NewString(kLibrary1Chars);
 
   result = Dart_LoadLibrary(Dart_Null(), source);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ("Dart_LoadLibrary expects argument 'url' to be non-null.",
                Dart_GetError(result));
@@ skipping 31 matching lines @@
   result = Dart_LoadLibrary(url, source);
   EXPECT(Dart_IsError(result));
   EXPECT_STREQ(
       "Dart_LoadLibrary: library 'library1_url' has already been loaded.",
       Dart_GetError(result));
 }
 
 
 TEST_CASE(LoadLibrary_CompileError) {
   const char* kLibrary1Chars =
-      "#library('library1_name');"
+      "library library1_name;"
       ")";
   Dart_Handle url = NewString("library1_url");
   Dart_Handle source = NewString(kLibrary1Chars);
   Dart_Handle result = Dart_LoadLibrary(url, source);
   EXPECT(Dart_IsError(result));
   EXPECT(strstr(Dart_GetError(result), "unexpected token ')'"));
 }
 
 
 TEST_CASE(LoadSource) {
   const char* kLibrary1Chars =
-      "#library('library1_name');";
+      "library library1_name;";
   const char* kSourceChars =
       "// Something innocuous";
   const char* kBadSourceChars =
       ")";
   Dart_Handle error = Dart_Error("incoming error");
   Dart_Handle result;
 
   // Load up a library.
   Dart_Handle url = NewString("library1_url");
   Dart_Handle source = NewString(kLibrary1Chars);
@@ skipping 62 matching lines @@
 
   // Language errors are detected.
   source = NewString(kBadSourceChars);
   result = Dart_LoadSource(lib, url, source);
   EXPECT(Dart_IsError(result));
 }
 
 
 TEST_CASE(LoadSource_LateLoad) {
   const char* kLibrary1Chars =
-      "#library('library1_name');\n"
+      "library library1_name;\n"
       "class OldClass {\n"
       "  foo() => 'foo';\n"
       "}\n";
   const char* kSourceChars =
       "class NewClass extends OldClass{\n"
       "  bar() => 'bar';\n"
       "}\n";
   Dart_Handle url = NewString("library1_url");
   Dart_Handle source = NewString(kLibrary1Chars);
   Dart_Handle lib = Dart_LoadLibrary(url, source);
@@ skipping 24 matching lines @@
   EXPECT_VALID(result);
   EXPECT(Dart_IsString(result));
   result_cstr = "";
   EXPECT_VALID(Dart_StringToCString(result, &result_cstr));
   EXPECT_STREQ("bar", result_cstr);
 }
 
 
 TEST_CASE(LoadPatch) {
   const char* kLibrary1Chars =
-      "#library('library1_name');";
+      "library library1_name;";
   const char* kSourceChars =
       "external int foo();";
   const char* kPatchChars =
       "patch int foo() => 42;";
 
   // Load up a library.
   Dart_Handle url = NewString("library1_url");
   Dart_Handle source = NewString(kLibrary1Chars);
   Dart_Handle lib = Dart_LoadLibrary(url, source);
   EXPECT_VALID(lib);
@@ skipping 28 matching lines @@
 
 
 static Dart_NativeFunction PatchNativeResolver(Dart_Handle name,
                                                int arg_count) {
   return &PatchNativeFunction;
 }
 
 
 TEST_CASE(ParsePatchLibrary) {
   const char* kLibraryChars =
-  "#library('patched_library');\n"
+  "library patched_library;\n"
   "class A {\n"
   "  final fvalue;\n"
   "  var _f;\n"
   "  callFunc(x, y) => x(y);\n"
   "  external method(var value);\n"
   "  get field => _field;\n"
   "}\n"
   "class B {\n"
   "  var val;\n"
   "  external B.named(x);\n"
@@ skipping 21 matching lines @@
   "  /*patch*/ factory B(v) native \"const_B_factory\";\n"
   "}\n"
   "var _topLevelValue = -1;\n"
   "patch int topLevel(var value) => value * value;\n"
   "patch int set topLevelSetter(value) { _topLevelValue = value; }\n"
   "patch int get topLevelGetter => 2 * _topLevelValue;\n"
   // Allow top level methods named patch.
   "patch(x) => x*3;\n";
 
   const char* kScriptChars =
-  "#import('theLibrary');\n"
+  "import 'theLibrary';\n"
   "e1() => unpatched();\n"
   "m1() => topLevel(2);\n"
   "m2() {\n"
   "  topLevelSetter = 20;\n"
   "  return topLevelGetter;\n"
   "}\n"
   "m3() => patch(7);\n"
   "m4() {\n"
   "  var a = new A();\n"
   "  a.method(5);\n"
@@ skipping 182 matching lines @@
 
   EXPECT_ERROR(Dart_Invoke(cls, NewString("baz"), 0, NULL),
                "native function 'SomeNativeFunction3' cannot be found");
 }
 
 
 // Test that an imported name does not clash with the same name defined
 // in the importing library.
 TEST_CASE(ImportLibrary2) {
   const char* kScriptChars =
-      "#import('library1.dart');\n"
+      "import 'library1_dart';\n"
       "var foo;\n"
       "main() { foo = 0; }\n";
   const char* kLibrary1Chars =
-      "#library('library1.dart');\n"
-      "#import('library2.dart');\n"
+      "library library1_dart;\n"
+      "import 'library2_dart';\n"
       "var foo;\n";
   const char* kLibrary2Chars =
-      "#library('library2.dart');\n"
-      "#import('library1.dart');\n"
+      "library library2_dart;\n"
+      "import 'library1_dart';\n"
       "var foo;\n";
   Dart_Handle result;
   // Create a test library and Load up a test script in it.
   Dart_Handle url = NewString(TestCase::url());
   Dart_Handle source = NewString(kScriptChars);
   result = Dart_SetLibraryTagHandler(library_handler);
   EXPECT_VALID(result);
   result = Dart_LoadScript(url, source);
 
-  url = NewString("library1.dart");
+  url = NewString("library1_dart");
   source = NewString(kLibrary1Chars);
   Dart_LoadLibrary(url, source);
 
-  url = NewString("library2.dart");
+  url = NewString("library2_dart");
   source = NewString(kLibrary2Chars);
   Dart_LoadLibrary(url, source);
 
   result = Dart_Invoke(result, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
 }
 
 
 // Test that if the same name is imported from two libraries, it is
 // an error if that name is referenced.
 TEST_CASE(ImportLibrary3) {
   const char* kScriptChars =
-      "#import('library2.dart');\n"
-      "#import('library1.dart');\n"
+      "import 'library2_dart';\n"
+      "import 'library1_dart';\n"
       "var foo_top = 10;  // foo has dup def. So should be an error.\n"
       "main() { foo = 0; }\n";
   const char* kLibrary1Chars =
-      "#library('library1.dart');\n"
+      "library library1_dart;\n"
       "var foo;";
   const char* kLibrary2Chars =
-      "#library('library2.dart');\n"
+      "library library2_dart;\n"
       "var foo;";
   Dart_Handle result;
 
   // Create a test library and Load up a test script in it.
   Dart_Handle url = NewString(TestCase::url());
   Dart_Handle source = NewString(kScriptChars);
   result = Dart_SetLibraryTagHandler(library_handler);
   EXPECT_VALID(result);
   result = Dart_LoadScript(url, source);
   EXPECT_VALID(result);
 
-  url = NewString("library2.dart");
+  url = NewString("library2_dart");
   source = NewString(kLibrary2Chars);
   Dart_LoadLibrary(url, source);
 
-  url = NewString("library1.dart");
+  url = NewString("library1_dart");
   source = NewString(kLibrary1Chars);
   Dart_LoadLibrary(url, source);
 
   result = Dart_Invoke(result, NewString("main"), 0, NULL);
   EXPECT(Dart_IsError(result));
   EXPECT_SUBSTRING("ambiguous reference: 'foo'", Dart_GetError(result));
 }
 
 
 // Test that if the same name is imported from two libraries, it is
 // not an error if that name is not used.
 TEST_CASE(ImportLibrary4) {
   const char* kScriptChars =
-      "#import('library2.dart');\n"
-      "#import('library1.dart');\n"
+      "import 'library2_dart';\n"
+      "import 'library1_dart';\n"
       "main() {  }\n";
   const char* kLibrary1Chars =
-      "#library('library1.dart');\n"
+      "library library1_dart;\n"
       "var foo;";
   const char* kLibrary2Chars =
-      "#library('library2.dart');\n"
+      "library library2_dart;\n"
       "var foo;";
   Dart_Handle result;
 
   // Create a test library and Load up a test script in it.
   Dart_Handle url = NewString(TestCase::url());
   Dart_Handle source = NewString(kScriptChars);
   result = Dart_SetLibraryTagHandler(library_handler);
   EXPECT_VALID(result);
   result = Dart_LoadScript(url, source);
   EXPECT_VALID(result);
 
-  url = NewString("library2.dart");
+  url = NewString("library2_dart");
   source = NewString(kLibrary2Chars);
   Dart_LoadLibrary(url, source);
 
-  url = NewString("library1.dart");
+  url = NewString("library1_dart");
   source = NewString(kLibrary1Chars);
   Dart_LoadLibrary(url, source);
 
   result = Dart_Invoke(result, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
 }
 
 
 TEST_CASE(ImportLibrary5) {
   const char* kScriptChars =
-      "#import('lib.dart');\n"
+      "import 'lib.dart';\n"
       "interface Y {\n"
       "  void set handler(void callback(List<int> x));\n"
       "}\n"
       "void main() {}\n";
   const char* kLibraryChars =
-      "#library('lib.dart');\n"
+      "library lib.dart;\n"
       "interface X {\n"
       "  void set handler(void callback(List<int> x));\n"
       "}\n";
   Dart_Handle result;
 
   // Create a test library and Load up a test script in it.
   Dart_Handle url = NewString(TestCase::url());
   Dart_Handle source = NewString(kScriptChars);
   result = Dart_SetLibraryTagHandler(library_handler);
   EXPECT_VALID(result);
@@ skipping 44 matching lines @@
   // Create a port with a bogus handler.
   Dart_Port error_port = Dart_NewNativePort("Foo", NULL, true);
   EXPECT_EQ(ILLEGAL_PORT, error_port);
 
   // Create the port w/o a current isolate, just to make sure that works.
   Dart_Port port_id1 =
       Dart_NewNativePort("Port123", NewNativePort_send123, true);
 
   TestIsolateScope __test_isolate__;
   const char* kScriptChars =
-      "#import('dart:isolate');\n"
+      "import 'dart:isolate';\n"
       "void callPort(SendPort port) {\n"
       "    port.call(null).then((message) {\n"
       "      throw new Exception(message);\n"
       "    });\n"
       "}\n";
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   Dart_EnterScope();
 
   // Create a port w/ a current isolate, to make sure that works too.
   Dart_Port port_id2 =
@@ skipping 30 matching lines @@
   EXPECT(Dart_CloseNativePort(port_id1));
   EXPECT(Dart_CloseNativePort(port_id2));
 }
 
 
 static bool RunLoopTestCallback(const char* script_name,
                                 const char* main,
                                 void* data,
                                 char** error) {
   const char* kScriptChars =
-      "#import('builtin');\n"
-      "#import('dart:isolate');\n"
+      "import 'builtin';\n"
+      "import 'dart:isolate';\n"
       "void entry() {\n"
       "  port.receive((message, replyTo) {\n"
       "    if (message) {\n"
       "      throw new Exception('MakeChildExit');\n"
       "    } else {\n"
       "      replyTo.call('hello');\n"
       "      port.close();\n"
       "    }\n"
       "  });\n"
       "}\n"
@@ skipping 968 matching lines @@
     EXPECT(o2 == reinterpret_cast<void*>(&p2));
   }
   Dart_ExitScope();
   isolate->heap()->CollectGarbage(Heap::kOld);
   EXPECT_EQ(0, isolate->heap()->PeerCount());
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart