clang-format runtime/vm

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 616 matching lines @@
       "}\n"
       "class B extends Object with Mixin1 {\n"
       "}\n"
       "var saved = new B();\n"
       "main() {\n"
       "  return 'saved:field=${saved.field},func=${saved.func()}';\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
-  EXPECT_STREQ("saved:field=mixin1,func=mixin1",
-               SimpleInvokeStr(lib, "main"));
+  EXPECT_STREQ("saved:field=mixin1,func=mixin1", SimpleInvokeStr(lib, "main"));
 
   const char* kReloadScript =
       "class Mixin2 {\n"
       "  var field = 'mixin2';\n"
       "  func() => 'mixin2';\n"
       "}\n"
       "class B extends Object with Mixin2 {\n"
       "}\n"
       "var saved = new B();\n"
       "main() {\n"
       "  var newer = new B();\n"
       "  return 'saved:field=${saved.field},func=${saved.func()} '\n"
       "         'newer:field=${newer.field},func=${newer.func()}';\n"
       "}\n";
 
   lib = TestCase::ReloadTestScript(kReloadScript);
   EXPECT_VALID(lib);
 
   // The saved instance of B retains its old field value from mixin1,
   // but it gets the new implementation of func from mixin2.
-  EXPECT_STREQ("saved:field=mixin1,func=mixin2 "
-               "newer:field=mixin2,func=mixin2",
-               SimpleInvokeStr(lib, "main"));
+  EXPECT_STREQ(
+      "saved:field=mixin1,func=mixin2 "
+      "newer:field=mixin2,func=mixin2",
+      SimpleInvokeStr(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_ComplexInheritanceChange) {
   const char* kScript =
       "class A {\n"
       "  String name;\n"
       "  A(this.name);\n"
       "}\n"
       "class B extends A {\n"
       "  B(name) : super(name);\n"
       "}\n"
       "class C extends B {\n"
       "  C(name) : super(name);\n"
       "}\n"
       "var list = [ new A('a'), new B('b'), new C('c') ];\n"
       "main() {\n"
       "  return (list.map((x) {\n"
       "    return '${x.name} is A(${x is A})/ B(${x is B})/ C(${x is C})';\n"
       "  })).toString();\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
-  EXPECT_STREQ("(a is A(true)/ B(false)/ C(false),"
-               " b is A(true)/ B(true)/ C(false),"
-               " c is A(true)/ B(true)/ C(true))",
-               SimpleInvokeStr(lib, "main"));
+  EXPECT_STREQ(
+      "(a is A(true)/ B(false)/ C(false),"
+      " b is A(true)/ B(true)/ C(false),"
+      " c is A(true)/ B(true)/ C(true))",
+      SimpleInvokeStr(lib, "main"));
 
   const char* kReloadScript =
       "class C {\n"
       "  String name;\n"
       "  C(this.name);\n"
       "}\n"
       "class X extends C {\n"
       "  X(name) : super(name);\n"
       "}\n"
       "class A extends X {\n"
       "  A(name) : super(name);\n"
       "}\n"
       "var list;\n"
       "main() {\n"
       "  list.add(new X('x'));\n"
       "  return (list.map((x) {\n"
       "    return '${x.name} is A(${x is A})/ C(${x is C})/ X(${x is X})';\n"
       "  })).toString();\n"
       "}\n";
 
   lib = TestCase::ReloadTestScript(kReloadScript);
   EXPECT_VALID(lib);
-  EXPECT_STREQ("(a is A(true)/ C(true)/ X(true),"
-               " b is A(true)/ C(true)/ X(true),"  // still extends A...
-               " c is A(false)/ C(true)/ X(false),"
-               " x is A(false)/ C(true)/ X(true))",
-               SimpleInvokeStr(lib, "main"));
+  EXPECT_STREQ(
+      "(a is A(true)/ C(true)/ X(true),"
+      " b is A(true)/ C(true)/ X(true),"  // still extends A...
+      " c is A(false)/ C(true)/ X(false),"
+      " x is A(false)/ C(true)/ X(true))",
+      SimpleInvokeStr(lib, "main"));
 
   // Revive the class B and make sure all allocated instances take
   // their place in the inheritance hierarchy.
   const char* kReloadScript2 =
       "class X {\n"
       "  String name;\n"
       "  X(this.name);\n"
       "}\n"
       "class A extends X{\n"
       "  A(name) : super(name);\n"
       "}\n"
       "class B extends X {\n"
       "  B(name) : super(name);\n"
       "}\n"
       "class C extends A {\n"
       "  C(name) : super(name);\n"
       "}\n"
       "var list;\n"
       "main() {\n"
       "  return (list.map((x) {\n"
       "    return '${x.name} is '\n"
       "           'A(${x is A})/ B(${x is B})/ C(${x is C})/ X(${x is X})';\n"
       "  })).toString();\n"
       "}\n";
 
   lib = TestCase::ReloadTestScript(kReloadScript2);
   EXPECT_VALID(lib);
-  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"));
+  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 'test:isolate_reload_helper';\n"
       "helper() => 7;\n"
       "alpha() { var x = helper(); reloadTest(); return x + helper(); }\n"
       "foo() => alpha();\n"
       "bar() => foo();\n"
@@ skipping 18 matching lines @@
 
   EXPECT_EQ(107, SimpleInvoke(lib, "main"));
 
   lib = TestCase::GetReloadErrorOrRootLibrary();
   EXPECT_VALID(lib);
   EXPECT_EQ(105, SimpleInvoke(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_LibraryLookup) {
-  const char* kImportScript =
-      "importedFunc() => 'a';\n";
+  const char* kImportScript = "importedFunc() => 'a';\n";
   TestCase::AddTestLib("test:lib1", kImportScript);
 
   const char* kScript =
       "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");
@@ skipping 21 matching lines @@
   lib = TestCase::ReloadTestScript(kScript);
   EXPECT_VALID(lib);
 
   // Fail to find 'test:lib1' in the isolate.
   result = Dart_LookupLibrary(NewString("test:lib1"));
   EXPECT(Dart_IsError(result));
 }
 
 
 TEST_CASE(IsolateReload_LibraryHide) {
-  const char* kImportScript =
-      "importedFunc() => 'a';\n";
+  const char* kImportScript = "importedFunc() => 'a';\n";
   TestCase::AddTestLib("test:lib1", kImportScript);
 
   // Import 'test:lib1' with importedFunc hidden. Will result in an
   // error.
   const char* kScript =
       "import 'test:lib1' hide importedFunc;\n"
       "main() {\n"
       "  return importedFunc();\n"
       "}\n";
 
@@ skipping 59 matching lines @@
   // 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* kImportScript =
-      "importedIntFunc() => 4;\n";
+  const char* kImportScript = "importedIntFunc() => 4;\n";
   TestCase::AddTestLib("test:lib1", kImportScript);
 
   const char* kScript =
       "import 'test:isolate_reload_helper';\n"
       "import 'test:lib1' show importedIntFunc;\n"
       "main() {\n"
       "  var x = importedIntFunc();\n"
       "  var y = importedIntFunc();\n"
       "  reloadTest();\n"
       "  return x + y;\n"
@@ skipping 665 matching lines @@
       "  C.y = 4;\n"
       "  var f = C#y;\n"
       "  var r1 = invoke(f);\n"
       "  reloadTest();\n"
       "  var r2 = invoke(f);\n"
       "  return '$r1 $r2';\n"
       "}\n";
 
   TestCase::SetReloadTestScript(kReloadScript);
 
-  EXPECT_STREQ("4 NoSuchMethodError: No static getter 'y' declared "
-               "in class 'C'.", SimpleInvokeStr(lib, "main"));
+  EXPECT_STREQ(
+      "4 NoSuchMethodError: No static getter 'y' declared "
+      "in class 'C'.",
+      SimpleInvokeStr(lib, "main"));
 
   lib = TestCase::GetReloadErrorOrRootLibrary();
   EXPECT_VALID(lib);
 }
 
 
 static void IsolateReload_DanlingGetter_LibraryReload(
     Dart_NativeArguments native_args) {
-  const char* kImportScript2 =
-    "var x;\n";
+  const char* kImportScript2 = "var x;\n";
   TestCase::AddTestLib("test:other", kImportScript2);
 
   DART_CHECK_VALID(TestCase::TriggerReload());
 }
 
 
 static Dart_NativeFunction IsolateReload_DanlingGetter_LibraryNativeResolver(
     Dart_Handle name,
     int num_of_arguments,
     bool* auto_setup_scope) {
@@ skipping 142 matching lines @@
       "  C.y = 4;\n"
       "  var f = C#y=;\n"
       "  var r1 = invoke(f, 5);\n"
       "  reloadTest();\n"
       "  var r2 = invoke(f, 6);\n"
       "  return '$r1 $r2';\n"
       "}\n";
 
   TestCase::SetReloadTestScript(kReloadScript);
 
-  EXPECT_STREQ("5 NoSuchMethodError: No static setter 'y=' declared in "
-               "class 'C'.", SimpleInvokeStr(lib, "main"));
+  EXPECT_STREQ(
+      "5 NoSuchMethodError: No static setter 'y=' declared in "
+      "class 'C'.",
+      SimpleInvokeStr(lib, "main"));
 
   lib = TestCase::GetReloadErrorOrRootLibrary();
   EXPECT_VALID(lib);
 }
 
 
 static void IsolateReload_DanlingSetter_LibraryReload(
     Dart_NativeArguments native_args) {
-  const char* kImportScript2 =
-    "var x;\n";
+  const char* kImportScript2 = "var x;\n";
   TestCase::AddTestLib("test:other", kImportScript2);
 
   DART_CHECK_VALID(TestCase::TriggerReload());
 }
 
 
 static Dart_NativeFunction IsolateReload_DanlingSetter_LibraryNativeResolver(
     Dart_Handle name,
     int num_of_arguments,
     bool* auto_setup_scope) {
@@ skipping 82 matching lines @@
       "  var c = new C();\n"
       "  var f = c#foo;\n"
       "  var r1 = invoke(f, 1);\n"
       "  reloadTest();\n"
       "  var r2 = invoke(f, 1);\n"
       "  return '$r1 $r2';\n"
       "}\n";
 
   TestCase::SetReloadTestScript(kReloadScript);
 
-  EXPECT_STREQ("1 NoSuchMethodError: Class 'C' has no instance method "
-               "'foo' with matching arguments.", SimpleInvokeStr(lib, "main"));
+  EXPECT_STREQ(
+      "1 NoSuchMethodError: Class 'C' has no instance method "
+      "'foo' with matching arguments.",
+      SimpleInvokeStr(lib, "main"));
 
   lib = TestCase::GetReloadErrorOrRootLibrary();
   EXPECT_VALID(lib);
 }
 
 
 TEST_CASE(IsolateReload_TearOff_AddArguments2) {
   const char* kScript =
       "import 'test:isolate_reload_helper';\n"
       "class C {\n"
@@ skipping 32 matching lines @@
       "main() {\n"
       "  var f = C#foo;\n"
       "  var r1 = invoke(f, 1);\n"
       "  reloadTest();\n"
       "  var r2 = invoke(f, 1);\n"
       "  return '$r1 $r2';\n"
       "}\n";
 
   TestCase::SetReloadTestScript(kReloadScript);
 
-  EXPECT_STREQ("1 NoSuchMethodError: Closure call with mismatched arguments: "
-               "function 'C.foo'", SimpleInvokeStr(lib, "main"));
+  EXPECT_STREQ(
+      "1 NoSuchMethodError: Closure call with mismatched arguments: "
+      "function 'C.foo'",
+      SimpleInvokeStr(lib, "main"));
 
   lib = TestCase::GetReloadErrorOrRootLibrary();
   EXPECT_VALID(lib);
 }
 
 
 TEST_CASE(IsolateReload_EnumEquality) {
   const char* kScript =
       "enum Fruit {\n"
       "  Apple,\n"
@@ skipping 215 matching lines @@
       "  Banana,\n"
       "}\n"
       "var x;\n"
       "main() {\n"
       "  String r = '$x ${x.hashCode is int} ${x.index}';\n"
       "  return r;\n"
       "}\n";
 
   lib = TestCase::ReloadTestScript(kReloadScript);
   EXPECT_VALID(lib);
-  EXPECT_STREQ("Fruit.Cantalope true 2",
-               SimpleInvokeStr(lib, "main"));
+  EXPECT_STREQ("Fruit.Cantalope true 2", SimpleInvokeStr(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_EnumIdentityReload) {
   const char* kScript =
       "enum Fruit {\n"
       "  Apple,\n"
       "  Banana,\n"
       "  Cantalope,\n"
       "}\n"
@@ skipping 685 matching lines @@
   EXPECT_STREQ("true", SimpleInvokeStr(lib, "main"));
 }
 
 
 static bool NothingModifiedCallback(const char* url, int64_t since) {
   return false;
 }
 
 
 TEST_CASE(IsolateReload_NoLibsModified) {
-  const char* kImportScript =
-      "importedFunc() => 'fancy';";
+  const char* kImportScript = "importedFunc() => 'fancy';";
   TestCase::AddTestLib("test:lib1", kImportScript);
 
   const char* kScript =
       "import 'test:lib1';\n"
       "main() {\n"
       "  return importedFunc() + ' feast';\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
   EXPECT_STREQ("fancy feast", SimpleInvokeStr(lib, "main"));
 
-  const char* kReloadImportScript =
-      "importedFunc() => 'bossy';";
+  const char* kReloadImportScript = "importedFunc() => 'bossy';";
   TestCase::AddTestLib("test:lib1", kReloadImportScript);
 
   const char* kReloadScript =
       "import 'test:lib1';\n"
       "main() {\n"
       "  return importedFunc() + ' pants';\n"
       "}\n";
 
   Dart_SetFileModifiedCallback(&NothingModifiedCallback);
   lib = TestCase::ReloadTestScript(kReloadScript);
   EXPECT_VALID(lib);
   Dart_SetFileModifiedCallback(NULL);
 
   // No reload occurred because no files were "modified".
   EXPECT_STREQ("fancy feast", SimpleInvokeStr(lib, "main"));
 }
 
 
 static bool MainModifiedCallback(const char* url, int64_t since) {
   if (strcmp(url, "test-lib") == 0) {
     return true;
   }
   return false;
 }
 
 
 TEST_CASE(IsolateReload_MainLibModified) {
-  const char* kImportScript =
-      "importedFunc() => 'fancy';";
+  const char* kImportScript = "importedFunc() => 'fancy';";
   TestCase::AddTestLib("test:lib1", kImportScript);
 
   const char* kScript =
       "import 'test:lib1';\n"
       "main() {\n"
       "  return importedFunc() + ' feast';\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
   EXPECT_STREQ("fancy feast", SimpleInvokeStr(lib, "main"));
 
-  const char* kReloadImportScript =
-      "importedFunc() => 'bossy';";
+  const char* kReloadImportScript = "importedFunc() => 'bossy';";
   TestCase::AddTestLib("test:lib1", kReloadImportScript);
 
   const char* kReloadScript =
       "import 'test:lib1';\n"
       "main() {\n"
       "  return importedFunc() + ' pants';\n"
       "}\n";
 
   Dart_SetFileModifiedCallback(&MainModifiedCallback);
   lib = TestCase::ReloadTestScript(kReloadScript);
   EXPECT_VALID(lib);
   Dart_SetFileModifiedCallback(NULL);
 
   // Imported library is not reloaded.
   EXPECT_STREQ("fancy pants", SimpleInvokeStr(lib, "main"));
 }
 
 
 static bool ImportModifiedCallback(const char* url, int64_t since) {
   if (strcmp(url, "test:lib1") == 0) {
     return true;
   }
   return false;
 }
 
 
 TEST_CASE(IsolateReload_ImportedLibModified) {
-  const char* kImportScript =
-      "importedFunc() => 'fancy';";
+  const char* kImportScript = "importedFunc() => 'fancy';";
   TestCase::AddTestLib("test:lib1", kImportScript);
 
   const char* kScript =
       "import 'test:lib1';\n"
       "main() {\n"
       "  return importedFunc() + ' feast';\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
   EXPECT_STREQ("fancy feast", SimpleInvokeStr(lib, "main"));
 
-  const char* kReloadImportScript =
-      "importedFunc() => 'bossy';";
+  const char* kReloadImportScript = "importedFunc() => 'bossy';";
   TestCase::AddTestLib("test:lib1", kReloadImportScript);
 
   const char* kReloadScript =
       "import 'test:lib1';\n"
       "main() {\n"
       "  return importedFunc() + ' pants';\n"
       "}\n";
 
   Dart_SetFileModifiedCallback(&ImportModifiedCallback);
   lib = TestCase::ReloadTestScript(kReloadScript);
   EXPECT_VALID(lib);
   Dart_SetFileModifiedCallback(NULL);
 
   // Modification of an imported library propagates to the importing library.
   EXPECT_STREQ("bossy pants", SimpleInvokeStr(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_PrefixImportedLibModified) {
-  const char* kImportScript =
-      "importedFunc() => 'fancy';";
+  const char* kImportScript = "importedFunc() => 'fancy';";
   TestCase::AddTestLib("test:lib1", kImportScript);
 
   const char* kScript =
       "import 'test:lib1' as cobra;\n"
       "main() {\n"
       "  return cobra.importedFunc() + ' feast';\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
   EXPECT_STREQ("fancy feast", SimpleInvokeStr(lib, "main"));
 
-  const char* kReloadImportScript =
-      "importedFunc() => 'bossy';";
+  const char* kReloadImportScript = "importedFunc() => 'bossy';";
   TestCase::AddTestLib("test:lib1", kReloadImportScript);
 
   const char* kReloadScript =
       "import 'test:lib1' as cobra;\n"
       "main() {\n"
       "  return cobra.importedFunc() + ' pants';\n"
       "}\n";
 
   Dart_SetFileModifiedCallback(&ImportModifiedCallback);
   lib = TestCase::ReloadTestScript(kReloadScript);
   EXPECT_VALID(lib);
   Dart_SetFileModifiedCallback(NULL);
 
   // Modification of an prefix-imported library propagates to the
   // importing library.
   EXPECT_STREQ("bossy pants", SimpleInvokeStr(lib, "main"));
 }
 
 
 static bool ExportModifiedCallback(const char* url, int64_t since) {
   if (strcmp(url, "test:exportlib") == 0) {
     return true;
   }
   return false;
 }
 
 
 TEST_CASE(IsolateReload_ExportedLibModified) {
-  const char* kImportScript =
-      "export 'test:exportlib';";
+  const char* kImportScript = "export 'test:exportlib';";
   TestCase::AddTestLib("test:importlib", kImportScript);
 
-  const char* kExportScript =
-      "exportedFunc() => 'fancy';";
+  const char* kExportScript = "exportedFunc() => 'fancy';";
   TestCase::AddTestLib("test:exportlib", kExportScript);
 
   const char* kScript =
       "import 'test:importlib';\n"
       "main() {\n"
       "  return exportedFunc() + ' feast';\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
   EXPECT_STREQ("fancy feast", SimpleInvokeStr(lib, "main"));
 
-  const char* kReloadExportScript =
-      "exportedFunc() => 'bossy';";
+  const char* kReloadExportScript = "exportedFunc() => 'bossy';";
   TestCase::AddTestLib("test:exportlib", kReloadExportScript);
 
   const char* kReloadScript =
       "import 'test:importlib';\n"
       "main() {\n"
       "  return exportedFunc() + ' pants';\n"
       "}\n";
 
   Dart_SetFileModifiedCallback(&ExportModifiedCallback);
   lib = TestCase::ReloadTestScript(kReloadScript);
   EXPECT_VALID(lib);
   Dart_SetFileModifiedCallback(NULL);
 
   // Modification of an exported library propagates.
   EXPECT_STREQ("bossy pants", SimpleInvokeStr(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_SimpleConstFieldUpdate) {
-    const char* kScript =
+  const char* kScript =
       "const value = 'a';\n"
       "main() {\n"
       "  return 'value=${value}';\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
   EXPECT_STREQ("value=a", SimpleInvokeStr(lib, "main"));
 
   const char* kReloadScript =
       "const value = 'b';\n"
       "main() {\n"
       "  return 'value=${value}';\n"
       "}\n";
 
   lib = TestCase::ReloadTestScript(kReloadScript);
   EXPECT_VALID(lib);
   EXPECT_STREQ("value=b", SimpleInvokeStr(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_ConstFieldUpdate) {
-    const char* kScript =
+  const char* kScript =
       "const value = const Duration(seconds: 1);\n"
       "main() {\n"
       "  return 'value=${value}';\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
   EXPECT_STREQ("value=0:00:01.000000", SimpleInvokeStr(lib, "main"));
 
   const char* kReloadScript =
       "const value = const Duration(seconds: 2);\n"
       "main() {\n"
       "  return 'value=${value}';\n"
       "}\n";
 
   lib = TestCase::ReloadTestScript(kReloadScript);
   EXPECT_VALID(lib);
   EXPECT_STREQ("value=0:00:02.000000", SimpleInvokeStr(lib, "main"));
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart