clang-format runtime/vm

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 36 matching lines @@
   while (test != NULL) {
     test->RunTest();
     test = test->next_;
   }
 }
 
 
 Dart_Isolate TestCase::CreateIsolate(const uint8_t* buffer, const char* name) {
   bin::IsolateData* isolate_data = new bin::IsolateData(name, NULL, NULL);
   char* err;
-  Dart_Isolate isolate = Dart_CreateIsolate(
-      name, NULL, buffer, NULL, isolate_data, &err);
+  Dart_Isolate isolate =
+      Dart_CreateIsolate(name, NULL, buffer, NULL, isolate_data, &err);
   if (isolate == NULL) {
     OS::Print("Creation of isolate failed '%s'\n", err);
     free(err);
   }
   EXPECT(isolate != NULL);
   return isolate;
 }
 
 
 static const char* kPackageScheme = "package:";
@@ skipping 42 matching lines @@
     }
   }
   return NULL;
 }
 
 #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,
+  return (strncmp(url_name, kIsolateReloadTestLibUri,
                   kIsolateReloadTestLibUriLen) == 0);
 }
 
 
 static Dart_Handle IsolateReloadTestLibSource() {
   // Special library with one function.
   return DartUtils::NewString("void reloadTest() native 'Reload_Test';\n");
 }
 
 
 static void ReloadTest(Dart_NativeArguments native_args) {
   DART_CHECK_VALID(TestCase::TriggerReload());
 }
 
 
 static Dart_NativeFunction IsolateReloadTestNativeResolver(
     Dart_Handle name,
     int num_of_arguments,
     bool* auto_setup_scope) {
   return ReloadTest;
 }
 #endif  // !PRODUCT
 
 
 static Dart_Handle ResolvePackageUri(const char* uri_chars) {
   const int kNumArgs = 1;
   Dart_Handle dart_args[kNumArgs];
   dart_args[0] = DartUtils::NewString(uri_chars);
   return Dart_Invoke(DartUtils::BuiltinLib(),
-                     DartUtils::NewString("_filePathFromUri"),
-                     kNumArgs,
+                     DartUtils::NewString("_filePathFromUri"), kNumArgs,
                      dart_args);
 }
 
 
 static ThreadLocalKey script_reload_key = kUnsetThreadLocalKey;
 
 static Dart_Handle LibraryTagHandler(Dart_LibraryTag tag,
                                      Dart_Handle library,
                                      Dart_Handle url) {
   if (tag == Dart_kCanonicalizeUrl) {
     Dart_Handle library_url = Dart_LibraryUrl(library);
     if (Dart_IsError(library_url)) {
       return library_url;
     }
     return Dart_DefaultCanonicalizeUrl(library_url, url);
   }
   if (tag == Dart_kScriptTag) {
     // Reload request.
     ASSERT(script_reload_key != kUnsetThreadLocalKey);
-    const char* script_source =
-       reinterpret_cast<const char*>(
-           OSThread::GetThreadLocal(script_reload_key));
+    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);
+    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");
   }
   const char* url_chars = NULL;
   Dart_Handle result = Dart_StringToCString(url, &url_chars);
   if (Dart_IsError(result)) {
@@ skipping 17 matching lines @@
       return Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
     } else {
       return DartUtils::NewError("Do not know how to load '%s'", url_chars);
     }
   }
   const char* lib_source = TestCase::GetTestLib(url_chars);
   if (lib_source != NULL) {
     Dart_Handle source = Dart_NewStringFromCString(lib_source);
     return Dart_LoadLibrary(url, Dart_Null(), source, 0, 0);
   }
-  NOT_IN_PRODUCT(
+#if !defined(PRODUCT)
   if (IsIsolateReloadTestLib(url_chars)) {
     Dart_Handle library =
         Dart_LoadLibrary(url, Dart_Null(), IsolateReloadTestLibSource(), 0, 0);
     DART_CHECK_VALID(library);
     Dart_SetNativeResolver(library, IsolateReloadTestNativeResolver, 0);
     return library;
-  })
+  }
+#endif
   if (is_io_library) {
     ASSERT(tag == Dart_kSourceTag);
-    return Dart_LoadSource(library,
-                           url, Dart_Null(),
-                           Builtin::PartSource(Builtin::kIOLibrary,
-                                               url_chars),
+    return Dart_LoadSource(library, 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)) {
     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");
     }
@@ skipping 127 matching lines @@
   return Api::Success();
 }
 
 
 char* TestCase::BigintToHexValue(Dart_CObject* bigint) {
   return bin::CObject::BigintToHexValue(bigint);
 }
 
 
 void AssemblerTest::Assemble() {
-  const String& function_name = String::ZoneHandle(
-      Symbols::New(Thread::Current(), name_));
+  const String& function_name =
+      String::ZoneHandle(Symbols::New(Thread::Current(), name_));
 
   // We make a dummy script so that exception objects can be composed for
   // assembler instructions that do runtime calls, in particular on DBC.
   const char* kDummyScript = "assembler_test_dummy_function() {}";
-  const Script& script = Script::Handle(Script::New(
-      function_name,
-      String::Handle(String::New(kDummyScript)),
-      RawScript::kSourceTag));
+  const Script& script = Script::Handle(
+      Script::New(function_name, String::Handle(String::New(kDummyScript)),
+                  RawScript::kSourceTag));
   script.Tokenize(String::Handle());
   const Library& lib = Library::Handle(Library::CoreLibrary());
   const Class& cls = Class::ZoneHandle(
-      Class::New(lib,
-                 function_name,
-                 script,
-                 TokenPosition::kMinSource));
+      Class::New(lib, function_name, script, TokenPosition::kMinSource));
   Function& function = Function::ZoneHandle(
-      Function::New(function_name, RawFunction::kRegularFunction,
-                    true, false, false, false, false, cls,
-                    TokenPosition::kMinSource));
+      Function::New(function_name, RawFunction::kRegularFunction, true, false,
+                    false, false, false, cls, TokenPosition::kMinSource));
   code_ = Code::FinalizeCode(function, assembler_);
   code_.set_owner(function);
   code_.set_exception_handlers(Object::empty_exception_handlers());
 #ifndef PRODUCT
   if (FLAG_disassemble) {
     OS::Print("Code for test '%s' {\n", name_);
     const Instructions& instructions =
         Instructions::Handle(code_.instructions());
     uword start = instructions.PayloadStart();
     Disassembler::Disassemble(start, start + assembler_->CodeSize());
     OS::Print("}\n");
   }
 #endif  // !PRODUCT
 }
 
 
 CodeGenTest::CodeGenTest(const char* name)
-  : function_(Function::ZoneHandle()),
-    node_sequence_(new SequenceNode(TokenPosition::kMinSource,
-                                    new LocalScope(NULL, 0, 0))),
-    default_parameter_values_(new ZoneGrowableArray<const Instance*> ()) {
+    : function_(Function::ZoneHandle()),
+      node_sequence_(new SequenceNode(TokenPosition::kMinSource,
+                                      new LocalScope(NULL, 0, 0))),
+      default_parameter_values_(new ZoneGrowableArray<const Instance*>()) {
   ASSERT(name != NULL);
-  const String& function_name = String::ZoneHandle(
-      Symbols::New(Thread::Current(), name));
+  const String& function_name =
+      String::ZoneHandle(Symbols::New(Thread::Current(), name));
   // Add function to a class and that class to the class dictionary so that
   // frame walking can be used.
   Library& lib = Library::Handle(Library::CoreLibrary());
-  const Class& cls = Class::ZoneHandle(
-      Class::New(lib, function_name, Script::Handle(),
-                  TokenPosition::kMinSource));
-  function_ = Function::New(
-      function_name, RawFunction::kRegularFunction,
-      true, false, false, false, false, cls, TokenPosition::kMinSource);
+  const Class& cls = Class::ZoneHandle(Class::New(
+      lib, function_name, Script::Handle(), TokenPosition::kMinSource));
+  function_ =
+      Function::New(function_name, RawFunction::kRegularFunction, true, false,
+                    false, false, false, cls, TokenPosition::kMinSource);
   function_.set_result_type(Type::Handle(Type::DynamicType()));
   const Array& functions = Array::Handle(Array::New(1));
   functions.SetAt(0, function_);
   cls.SetFunctions(functions);
   lib.AddClass(cls);
 }
 
 
 void CodeGenTest::Compile() {
   if (function_.HasCode()) return;
   ParsedFunction* parsed_function =
       new ParsedFunction(Thread::Current(), function_);
   parsed_function->SetNodeSequence(node_sequence_);
   parsed_function->set_instantiator(NULL);
   parsed_function->set_default_parameter_values(default_parameter_values_);
-  node_sequence_->scope()->AddVariable(
-      parsed_function->current_context_var());
+  node_sequence_->scope()->AddVariable(parsed_function->current_context_var());
   parsed_function->EnsureExpressionTemp();
   node_sequence_->scope()->AddVariable(parsed_function->expression_temp_var());
   parsed_function->AllocateVariables();
   const Error& error =
       Error::Handle(Compiler::CompileParsedFunction(parsed_function));
   EXPECT(error.IsNull());
 }
 
 
 bool CompilerTest::TestCompileScript(const Library& library,
                                      const Script& script) {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   const Error& error = Error::Handle(Compiler::Compile(library, script));
   if (!error.IsNull()) {
-    OS::Print("Error compiling test script:\n%s\n",
-    error.ToErrorCString());
+    OS::Print("Error compiling test script:\n%s\n", error.ToErrorCString());
   }
   return error.IsNull();
 }
 
 
 bool CompilerTest::TestCompileFunction(const Function& function) {
   Thread* thread = Thread::Current();
   ASSERT(thread != NULL);
   ASSERT(ClassFinalizer::AllClassesFinalized());
-  const Error& error = Error::Handle(Compiler::CompileFunction(thread,
-                                                               function));
+  const Error& error =
+      Error::Handle(Compiler::CompileFunction(thread, function));
   return error.IsNull();
 }
 
 
 void ElideJSONSubstring(const char* prefix, const char* in, char* out) {
   const char* pos = strstr(in, prefix);
   while (pos != NULL) {
     // Copy up to pos into the output buffer.
     while (in < pos) {
       *out++ = *in++;
     }
 
     // Skip to the close quote.
     in += strcspn(in, "\"");
     pos = strstr(in, prefix);
   }
   // Copy the remainder of in to out.
   while (*in != '\0') {
     *out++ = *in++;
   }
   *out = '\0';
 }
 
 
 }  // namespace dart