Only reload libraries when they may have been modified.

runtime/vm/unit_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 "vm/unit_test.h"
 
 #include <stdio.h>
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
@@ skipping 63 matching lines @@
 }
 
 
 static bool IsImportableTestLib(const char* url_name) {
   const char* kImportTestLibUri = "test:importable_lib";
   static const intptr_t kImportTestLibUriLen = strlen(kImportTestLibUri);
   return (strncmp(url_name, kImportTestLibUri, kImportTestLibUriLen) == 0);
 }
 
 
+const char* kDefaultImportableTestLibScript =
+    "importedFunc() => 'a';\n"
+    "importedIntFunc() => 4;\n"
+    "class ImportedMixin {\n"
+    "  mixinFunc() => 'mixin';\n"
+    "}\n";
+const char* importable_test_lib_script = kDefaultImportableTestLibScript;
+
+
+void TestCase::SetImportableTestLibScript(const char* source) {
+  importable_test_lib_script = source;
+}
+
+
+void TestCase::RestoreImportableTestLibScript() {
+  importable_test_lib_script = kDefaultImportableTestLibScript;
+}
+
+
 static Dart_Handle ImportableTestLibSource() {
-  const char* kScript =
-      "importedFunc() => 'a';\n"
-      "importedIntFunc() => 4;\n"
-      "class ImportedMixin {\n"
-      "  mixinFunc() => 'mixin';\n"
-      "}\n";
-  return DartUtils::NewString(kScript);
+  return DartUtils::NewString(importable_test_lib_script);
 }
 
 
 #ifndef PRODUCT
 static bool IsIsolateReloadTestLib(const char* url_name) {
   const char* kIsolateReloadTestLibUri = "test:isolate_reload_helper";
   static const intptr_t kIsolateReloadTestLibUriLen =
       strlen(kIsolateReloadTestLibUri);
   return (strncmp(url_name,
                   kIsolateReloadTestLibUri,
@@ skipping 46 matching lines @@
   }
   if (tag == Dart_kScriptTag) {
     // Reload request.
     ASSERT(script_reload_key != kUnsetThreadLocalKey);
     const char* script_source =
        reinterpret_cast<const char*>(
            OSThread::GetThreadLocal(script_reload_key));
     ASSERT(script_source != NULL);
     OSThread::SetThreadLocal(script_reload_key, 0);
     return Dart_LoadScript(url,
+                           Dart_Null(),
                            NewString(script_source),
                            0,
                            0);
   }
   if (!Dart_IsLibrary(library)) {
     return Dart_NewApiError("not a library");
   }
   if (!Dart_IsString(url)) {
     return Dart_NewApiError("url is not a string");
   }
@@ skipping 16 matching lines @@
     // Handle imports of other built-in libraries present in the SDK.
     if (DartUtils::IsDartIOLibURL(url_chars)) {
       return Builtin::LoadAndCheckLibrary(Builtin::kIOLibrary);
     } else if (DartUtils::IsDartBuiltinLibURL(url_chars)) {
       return Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
     } else {
       return DartUtils::NewError("Do not know how to load '%s'", url_chars);
     }
   }
   if (IsImportableTestLib(url_chars)) {
-    return Dart_LoadLibrary(url, ImportableTestLibSource(), 0, 0);
+    return Dart_LoadLibrary(url, Dart_Null(), ImportableTestLibSource(), 0, 0);
   }
   NOT_IN_PRODUCT(
   if (IsIsolateReloadTestLib(url_chars)) {
     Dart_Handle library =
-        Dart_LoadLibrary(url, IsolateReloadTestLibSource(), 0, 0);
+        Dart_LoadLibrary(url, Dart_Null(), IsolateReloadTestLibSource(), 0, 0);
     DART_CHECK_VALID(library);
     Dart_SetNativeResolver(library, IsolateReloadTestNativeResolver, 0);
     return library;
   })
   if (is_io_library) {
     ASSERT(tag == Dart_kSourceTag);
     return Dart_LoadSource(library,
-                           url,
+                           url, Dart_Null(),
                            Builtin::PartSource(Builtin::kIOLibrary,
                                                url_chars),
                            0, 0);
   }
+  Dart_Handle resolved_url = url;
+  const char* resolved_url_chars = url_chars;
   if (IsPackageSchemeURL(url_chars)) {
-    Dart_Handle resolved_uri = ResolvePackageUri(url_chars);
-    DART_CHECK_VALID(resolved_uri);
-    url_chars = NULL;
-    Dart_Handle result = Dart_StringToCString(resolved_uri, &url_chars);
-    if (Dart_IsError(result)) {
-      return Dart_NewApiError("accessing url characters failed");
+    resolved_url = ResolvePackageUri(url_chars);
+    DART_CHECK_VALID(resolved_url);
+    if (Dart_IsError(Dart_StringToCString(resolved_url, &resolved_url_chars))) {
+      return Dart_NewApiError("unable to convert resolved uri to string");
     }
   }
   // Do sync loading since unit_test doesn't support async.
-  Dart_Handle source = DartUtils::ReadStringFromFile(url_chars);
+  Dart_Handle source = DartUtils::ReadStringFromFile(resolved_url_chars);
   EXPECT_VALID(source);
   if (tag == Dart_kImportTag) {
-    return Dart_LoadLibrary(url, source, 0, 0);
+    return Dart_LoadLibrary(url, resolved_url, source, 0, 0);
   } else {
     ASSERT(tag == Dart_kSourceTag);
-    return Dart_LoadSource(library, url, source, 0, 0);
+    return Dart_LoadSource(library, url, resolved_url, source, 0, 0);
   }
 }
 
 
 Dart_Handle TestCase::LoadTestScript(const char* script,
                                      Dart_NativeEntryResolver resolver,
                                      const char* lib_url,
                                      bool finalize_classes) {
   Dart_Handle url = NewString(lib_url);
   Dart_Handle source = NewString(script);
   Dart_Handle result = Dart_SetLibraryTagHandler(LibraryTagHandler);
   EXPECT_VALID(result);
-  Dart_Handle lib = Dart_LoadScript(url, source, 0, 0);
+  Dart_Handle lib = Dart_LoadScript(url, Dart_Null(), source, 0, 0);
   DART_CHECK_VALID(lib);
   result = Dart_SetNativeResolver(lib, resolver, NULL);
   DART_CHECK_VALID(result);
   if (finalize_classes) {
     result = Dart_FinalizeLoading(false);
     DART_CHECK_VALID(result);
   }
   return lib;
 }
 
@@ skipping 10 matching lines @@
   // Store the new script in TLS.
   OSThread::SetThreadLocal(script_reload_key, reinterpret_cast<uword>(script));
 }
 
 
 Dart_Handle TestCase::TriggerReload() {
   Isolate* isolate = Isolate::Current();
 
   {
     TransitionNativeToVM transition(Thread::Current());
-    isolate->ReloadSources(/* dont_delete_reload_context = */ true);
+    isolate->ReloadSources(false,  // force_reload
+                           true);  // dont_delete_reload_context
   }
 
   return Dart_FinalizeLoading(false);
 }
 
 
 Dart_Handle TestCase::GetReloadErrorOrRootLibrary() {
   Isolate* isolate = Isolate::Current();
 
   if (isolate->reload_context() != NULL &&
@@ skipping 176 matching lines @@
   }
   // Copy the remainder of in to out.
   while (*in != '\0') {
     *out++ = *in++;
   }
   *out = '\0';
 }
 
 
 }  // namespace dart