Canonicalize uris in C++ instead of Dart for the standalone embedder.

runtime/vm/isolate_reload_test.cc

 // Copyright (c) 2016, 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 "include/dart_tools_api.h"
 #include "platform/assert.h"
 #include "vm/globals.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
@@ skipping 630 matching lines @@
   EXPECT_STREQ("(a is A(true)/ B(false)/ C(false)/ X(true),"
                " b is A(false)/ B(true)/ C(false)/ X(true),"
                " c is A(true)/ B(false)/ C(true)/ X(true),"
                " x is A(false)/ B(false)/ C(false)/ X(true))",
                SimpleInvokeStr(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_LiveStack) {
   const char* kScript =
-      "import 'isolate_reload_test_helper';\n"
+      "import 'test:isolate_reload_helper';\n"
       "helper() => 7;\n"
       "alpha() { var x = helper(); reloadTest(); return x + helper(); }\n"
       "foo() => alpha();\n"
       "bar() => foo();\n"
       "main() {\n"
       "  return bar();\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
 
   const char* kReloadScript =
-      "import 'isolate_reload_test_helper';\n"
+      "import 'test:isolate_reload_helper';\n"
       "helper() => 100;\n"
       "alpha() => 5 + helper();\n"
       "foo() => alpha();\n"
       "bar() => foo();\n"
       "main() {\n"
       "  return bar();\n"
       "}\n";
 
   TestCase::SetReloadTestScript(kReloadScript);
 
@@ skipping 12 matching lines @@
       "  return importedFunc();\n"
       "}\n";
 
   Dart_Handle result;
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
 
   EXPECT_ERROR(SimpleInvokeError(lib, "main"), "importedFunc");
 
-  // Fail to find 'importable_test_lib' in the isolate.
-  result = Dart_LookupLibrary(NewString("importable_test_lib"));
+  // Fail to find 'test:importable_lib' in the isolate.
+  result = Dart_LookupLibrary(NewString("test:importable_lib"));
   EXPECT(Dart_IsError(result));
 
   const char* kReloadScript =
-      "import 'importable_test_lib';\n"
+      "import 'test:importable_lib';\n"
       "main() {\n"
       "  return importedFunc();\n"
       "}\n";
 
-  // Reload and add 'importable_test_lib' to isolate.
+  // Reload and add 'test:importable_lib' to isolate.
   lib = TestCase::ReloadTestScript(kReloadScript);
   EXPECT_VALID(lib);
 
   EXPECT_STREQ("a", SimpleInvokeStr(lib, "main"));
 
-  // Find 'importable_test_lib' in the isolate.
-  result = Dart_LookupLibrary(NewString("importable_test_lib"));
+  // Find 'test:importable_lib' in the isolate.
+  result = Dart_LookupLibrary(NewString("test:importable_lib"));
   EXPECT(Dart_IsLibrary(result));
 
   // Reload and remove 'dart:math' from isolate.
   lib = TestCase::ReloadTestScript(kScript);
   EXPECT_VALID(lib);
 
-  // Fail to find 'importable_test_lib' in the isolate.
-  result = Dart_LookupLibrary(NewString("importable_test_lib"));
+  // Fail to find 'test:importable_lib' in the isolate.
+  result = Dart_LookupLibrary(NewString("test:importable_lib"));
   EXPECT(Dart_IsError(result));
 }
 
 
 TEST_CASE(IsolateReload_LibraryHide) {
-  // Import 'importable_test_lib' with importedFunc hidden. Will result in an
+  // Import 'test:importable_lib' with importedFunc hidden. Will result in an
   // error.
   const char* kScript =
-      "import 'importable_test_lib' hide importedFunc;\n"
+      "import 'test:importable_lib' hide importedFunc;\n"
       "main() {\n"
       "  return importedFunc();\n"
       "}\n";
 
   // Dart_Handle result;
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
 
   EXPECT_ERROR(SimpleInvokeError(lib, "main"), "importedFunc");
 
-  // Import 'importable_test_lib'.
+  // Import 'test:importable_lib'.
   const char* kReloadScript =
-      "import 'importable_test_lib';\n"
+      "import 'test:importable_lib';\n"
       "main() {\n"
       "  return importedFunc();\n"
       "}\n";
 
   lib = TestCase::ReloadTestScript(kReloadScript);
   EXPECT_VALID(lib);
 
   EXPECT_STREQ("a", SimpleInvokeStr(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_LibraryShow) {
-  // Import 'importable_test_lib' with importedIntFunc visible. Will result in
+  // Import 'test:importable_lib' with importedIntFunc visible. Will result in
   // an error when 'main' is invoked.
   const char* kScript =
-      "import 'importable_test_lib' show importedIntFunc;\n"
+      "import 'test:importable_lib' show importedIntFunc;\n"
       "main() {\n"
       "  return importedFunc();\n"
       "}\n"
       "mainInt() {\n"
       "  return importedIntFunc();\n"
       "}\n";
 
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
 
   // Works.
   EXPECT_EQ(4, SimpleInvoke(lib, "mainInt"));
   // Results in an error.
   EXPECT_ERROR(SimpleInvokeError(lib, "main"), "importedFunc");
 
-  // Import 'importable_test_lib' with importedFunc visible. Will result in
+  // Import 'test:importable_lib' with importedFunc visible. Will result in
   // an error when 'mainInt' is invoked.
   const char* kReloadScript =
-      "import 'importable_test_lib' show importedFunc;\n"
+      "import 'test:importable_lib' show importedFunc;\n"
       "main() {\n"
       "  return importedFunc();\n"
       "}\n"
       "mainInt() {\n"
       "  return importedIntFunc();\n"
       "}\n";
 
   lib = TestCase::ReloadTestScript(kReloadScript);
   EXPECT_VALID(lib);
 
   // Works.
   EXPECT_STREQ("a", SimpleInvokeStr(lib, "main"));
   // Results in an error.
   EXPECT_ERROR(SimpleInvokeError(lib, "mainInt"), "importedIntFunc");
 }
 
 
 // Verifies that we clear the ICs for the functions live on the stack in a way
 // that is compatible with the fast path smi stubs.
 TEST_CASE(IsolateReload_SmiFastPathStubs) {
   const char* kScript =
-      "import 'isolate_reload_test_helper';\n"
-      "import 'importable_test_lib' show importedIntFunc;\n"
+      "import 'test:isolate_reload_helper';\n"
+      "import 'test:importable_lib' show importedIntFunc;\n"
       "main() {\n"
       "  var x = importedIntFunc();\n"
       "  var y = importedIntFunc();\n"
       "  reloadTest();\n"
       "  return x + y;\n"
       "}\n";
 
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
 
   // Identity reload.
   TestCase::SetReloadTestScript(kScript);
 
   EXPECT_EQ(8, SimpleInvoke(lib, "main"));
 }
 
 
 // Verifies that we assign the correct patch classes for imported
 // mixins when we reload.
 TEST_CASE(IsolateReload_ImportedMixinFunction) {
   const char* kScript =
-      "import 'importable_test_lib' show ImportedMixin;\n"
+      "import 'test:importable_lib' show ImportedMixin;\n"
       "class A extends Object with ImportedMixin {\n"
       "}"
       "var func = new A().mixinFunc;\n"
       "main() {\n"
       "  return func();\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
 
   EXPECT_STREQ("mixin", SimpleInvokeStr(lib, "main"));
 
   const char* kReloadScript =
-      "import 'importable_test_lib' show ImportedMixin;\n"
+      "import 'test:importable_lib' show ImportedMixin;\n"
       "class A extends Object with ImportedMixin {\n"
       "}"
       "var func;\n"
       "main() {\n"
       "  return func();\n"
       "}\n";
 
   lib = TestCase::ReloadTestScript(kReloadScript);
   EXPECT_VALID(lib);
 
@@ skipping 18 matching lines @@
       "  return 4;\n"
       "}\n";
 
   lib = TestCase::ReloadTestScript(kReloadScript);
   EXPECT_ERROR(lib, "unexpected token");
 }
 
 
 TEST_CASE(IsolateReload_PendingUnqualifiedCall_StaticToInstance) {
   const char* kScript =
-      "import 'isolate_reload_test_helper';\n"
+      "import 'test:isolate_reload_helper';\n"
       "class C {\n"
       "  static foo() => 'static';\n"
       "  test() {\n"
       "    reloadTest();\n"
       "    return foo();\n"
       "  }\n"
       "}\n"
       "main() {\n"
       "  return new C().test();\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
 
   const char* kReloadScript =
-      "import 'isolate_reload_test_helper';\n"
+      "import 'test:isolate_reload_helper';\n"
       "class C {\n"
       "  foo() => 'instance';\n"
       "  test() {\n"
       "    reloadTest();\n"
       "    return foo();\n"
       "  }\n"
       "}\n"
       "main() {\n"
       "  return new C().test();\n"
       "}\n";
 
   TestCase::SetReloadTestScript(kReloadScript);
 
   EXPECT_EQ("instance", SimpleInvokeStr(lib, "main"));
 
   lib = TestCase::GetReloadErrorOrRootLibrary();
   EXPECT_VALID(lib);
 
   EXPECT_EQ("instance", SimpleInvokeStr(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_PendingUnqualifiedCall_InstanceToStatic) {
   const char* kScript =
-      "import 'isolate_reload_test_helper';\n"
+      "import 'test:isolate_reload_helper';\n"
       "class C {\n"
       "  foo() => 'instance';\n"
       "  test() {\n"
       "    reloadTest();\n"
       "    return foo();\n"
       "  }\n"
       "}\n"
       "main() {\n"
       "  return new C().test();\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
 
   const char* kReloadScript =
-      "import 'isolate_reload_test_helper';\n"
+      "import 'test:isolate_reload_helper';\n"
       "class C {\n"
       "  static foo() => 'static';\n"
       "  test() {\n"
       "    reloadTest();\n"
       "    return foo();\n"
       "  }\n"
       "}\n"
       "main() {\n"
       "  return new C().test();\n"
       "}\n";
 
   TestCase::SetReloadTestScript(kReloadScript);
 
   EXPECT_EQ("static", SimpleInvokeStr(lib, "main"));
 
   lib = TestCase::GetReloadErrorOrRootLibrary();
   EXPECT_VALID(lib);
 
   EXPECT_EQ("static", SimpleInvokeStr(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_PendingConstructorCall_AbstractToConcrete) {
   const char* kScript =
-      "import 'isolate_reload_test_helper';\n"
+      "import 'test:isolate_reload_helper';\n"
       "abstract class Foo {}\n"
       "class C {\n"
       "  test() {\n"
       "    reloadTest();\n"
       "    return new Foo();\n"
       "  }\n"
       "}\n"
       "main() {\n"
       "  try {\n"
       "    new C().test();\n"
       "    return 'okay';\n"
       "  } catch (e) {\n"
       "    return 'exception';\n"
       "  }\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
 
   const char* kReloadScript =
-      "import 'isolate_reload_test_helper';\n"
+      "import 'test:isolate_reload_helper';\n"
       "class Foo {}\n"
       "class C {\n"
       "  test() {\n"
       "    reloadTest();\n"
       "    return new Foo();\n"
       "  }\n"
       "}\n"
       "main() {\n"
       "  try {\n"
       "    new C().test();\n"
       "    return 'okay';\n"
       "  } catch (e) {\n"
       "    return 'exception';\n"
       "  }\n"
       "}\n";
 
   TestCase::SetReloadTestScript(kReloadScript);
 
   EXPECT_EQ("okay", SimpleInvokeStr(lib, "main"));
 
   lib = TestCase::GetReloadErrorOrRootLibrary();
   EXPECT_VALID(lib);
 
   EXPECT_EQ("okay", SimpleInvokeStr(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_PendingConstructorCall_ConcreteToAbstract) {
   const char* kScript =
-      "import 'isolate_reload_test_helper';\n"
+      "import 'test:isolate_reload_helper';\n"
       "class Foo {}\n"
       "class C {\n"
       "  test() {\n"
       "    reloadTest();\n"
       "    return new Foo();\n"
       "  }\n"
       "}\n"
       "main() {\n"
       "  try {\n"
       "    new C().test();\n"
       "    return 'okay';\n"
       "  } catch (e) {\n"
       "    return 'exception';\n"
       "  }\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
 
   const char* kReloadScript =
-      "import 'isolate_reload_test_helper';\n"
+      "import 'test:isolate_reload_helper';\n"
       "abstract class Foo {}\n"
       "class C {\n"
       "  test() {\n"
       "    reloadTest();\n"
       "    return new Foo();\n"
       "  }\n"
       "}\n"
       "main() {\n"
       "  try {\n"
       "    new C().test();\n"
       "    return 'okay';\n"
       "  } catch (e) {\n"
       "    return 'exception';\n"
       "  }\n"
       "}\n";
 
   TestCase::SetReloadTestScript(kReloadScript);
 
   EXPECT_EQ("exception", SimpleInvokeStr(lib, "main"));
 
   lib = TestCase::GetReloadErrorOrRootLibrary();
   EXPECT_VALID(lib);
 
   EXPECT_EQ("exception", SimpleInvokeStr(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_PendingStaticCall_DefinedToNSM) {
   const char* kScript =
-      "import 'isolate_reload_test_helper';\n"
+      "import 'test:isolate_reload_helper';\n"
       "class C {\n"
       "  static foo() => 'static'\n"
       "  test() {\n"
       "    reloadTest();\n"
       "    return C.foo();\n"
       "  }\n"
       "}\n"
       "main() {\n"
       "  try {\n"
       "    return new C().test();\n"
       "  } catch (e) {\n"
       "    return 'exception';\n"
       "  }\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
 
   const char* kReloadScript =
-      "import 'isolate_reload_test_helper';\n"
+      "import 'test:isolate_reload_helper';\n"
       "class C {\n"
       "  test() {\n"
       "    reloadTest();\n"
       "    return C.foo();\n"
       "  }\n"
       "}\n"
       "main() {\n"
       "  try {\n"
       "    return new C().test();\n"
       "  } catch (e) {\n"
       "    return 'exception';\n"
       "  }\n"
       "}\n";
 
   TestCase::SetReloadTestScript(kReloadScript);
 
   EXPECT_EQ("exception", SimpleInvokeStr(lib, "main"));
 
   lib = TestCase::GetReloadErrorOrRootLibrary();
   EXPECT_VALID(lib);
 
   EXPECT_EQ("exception", SimpleInvokeStr(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_PendingStaticCall_NSMToDefined) {
   const char* kScript =
-      "import 'isolate_reload_test_helper';\n"
+      "import 'test:isolate_reload_helper';\n"
       "class C {\n"
       "  test() {\n"
       "    reloadTest();\n"
       "    return C.foo();\n"
       "  }\n"
       "}\n"
       "main() {\n"
       "  try {\n"
       "    return new C().test();\n"
       "  } catch (e) {\n"
       "    return 'exception';\n"
       "  }\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
 
   const char* kReloadScript =
-      "import 'isolate_reload_test_helper';\n"
+      "import 'test:isolate_reload_helper';\n"
       "class C {\n"
       "  static foo() => 'static'\n"
       "  test() {\n"
       "    reloadTest();\n"
       "    return C.foo();\n"
       "  }\n"
       "}\n"
       "main() {\n"
       "  try {\n"
       "    return new C().test();\n"
@@ skipping 681 matching lines @@
 
   // ...and the non-core subclass is still named AIterator.
   new_subclass = subclasses.At(subclasses.Length() - 1);
   name = Class::Cast(new_subclass).Name();
   EXPECT_STREQ("AIterator", name.ToCString());
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart