VM: Re-format to use at most one newline between functions

runtime/vm/unit_test.h

 // Copyright (c) 2011, 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.
 
 #ifndef RUNTIME_VM_UNIT_TEST_H_
 #define RUNTIME_VM_UNIT_TEST_H_
 
 #include "include/dart_native_api.h"
 
 #include "platform/globals.h"
@@ skipping 86 matching lines @@
 // Populate node list with AST nodes.
 #define CODEGEN_TEST_GENERATE(name, test)                                      \
   static void CodeGenTestGenerate##name(CodeGenTest* test)
 
 // Populate node list with AST nodes, possibly using the provided function
 // object built by a previous CODEGEN_TEST_GENERATE.
 #define CODEGEN_TEST2_GENERATE(name, function, test)                           \
   static void CodeGenTestGenerate##name(const Function& function,              \
                                         CodeGenTest* test)
 
-
 // Pass the name of test and the expected results as RawObject.
 #define CODEGEN_TEST_RUN(name, expected)                                       \
   static void CodeGenTestRun##name(const Function& function);                  \
   ISOLATE_UNIT_TEST_CASE(name) {                                               \
     CodeGenTest __test__("" #name);                                            \
     CodeGenTestGenerate##name(&__test__);                                      \
     __test__.Compile();                                                        \
     CodeGenTestRun##name(__test__.function());                                 \
   }                                                                            \
   static void CodeGenTestRun##name(const Function& function) {                 \
     Object& result = Object::Handle();                                         \
     result = DartEntry::InvokeFunction(function, Object::empty_array());       \
     EXPECT(!result.IsError());                                                 \
     Instance& actual = Instance::Handle();                                     \
     actual ^= result.raw();                                                    \
     EXPECT(actual.CanonicalizeEquals(Instance::Handle(expected)));             \
   }
 
-
 // Pass the name of test, and use the generated function to call it
 // and evaluate its result.
 #define CODEGEN_TEST_RAW_RUN(name, function)                                   \
   static void CodeGenTestRun##name(const Function& function);                  \
   ISOLATE_UNIT_TEST_CASE(name) {                                               \
     CodeGenTest __test__("" #name);                                            \
     CodeGenTestGenerate##name(&__test__);                                      \
     __test__.Compile();                                                        \
     CodeGenTestRun##name(__test__.function());                                 \
   }                                                                            \
   static void CodeGenTestRun##name(const Function& function)
 
-
 // Generate code for two sequences of AST nodes and execute the first one.
 // The first one may reference the Function object generated by the second one.
 #define CODEGEN_TEST2_RUN(name1, name2, expected)                              \
   static void CodeGenTestRun##name1(const Function& function);                 \
   ISOLATE_UNIT_TEST_CASE(name1) {                                              \
     /* Generate code for name2 */                                              \
     CodeGenTest __test2__("" #name2);                                          \
     CodeGenTestGenerate##name2(&__test2__);                                    \
     __test2__.Compile();                                                       \
     /* Generate code for name1, providing function2 */                         \
     CodeGenTest __test1__("" #name1);                                          \
     CodeGenTestGenerate##name1(__test2__.function(), &__test1__);              \
     __test1__.Compile();                                                       \
     CodeGenTestRun##name1(__test1__.function());                               \
   }                                                                            \
   static void CodeGenTestRun##name1(const Function& function) {                \
     Object& result = Object::Handle();                                         \
     result = DartEntry::InvokeFunction(function, Object::empty_array());       \
     EXPECT(!result.IsError());                                                 \
     Instance& actual = Instance::Handle();                                     \
     actual ^= result.raw();                                                    \
     EXPECT(actual.CanonicalizeEquals(Instance::Handle(expected)));             \
   }
 
-
 #if defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_ARM64)
 #if defined(HOST_ARCH_ARM) || defined(HOST_ARCH_ARM64)
 // Running on actual ARM hardware, execute code natively.
 #define EXECUTE_TEST_CODE_INT32(name, entry) reinterpret_cast<name>(entry)()
 #define EXECUTE_TEST_CODE_INT64(name, entry) reinterpret_cast<name>(entry)()
 #define EXECUTE_TEST_CODE_INT64_LL(name, entry, long_arg0, long_arg1)          \
   reinterpret_cast<name>(entry)(long_arg0, long_arg1)
 #define EXECUTE_TEST_CODE_FLOAT(name, entry) reinterpret_cast<name>(entry)()
 #define EXECUTE_TEST_CODE_DOUBLE(name, entry) reinterpret_cast<name>(entry)()
 #define EXECUTE_TEST_CODE_INT32_F(name, entry, float_arg)                      \
@@ skipping 51 matching lines @@
       0, 0, false, true))
 #define EXECUTE_TEST_CODE_INT32_D(name, entry, double_arg)                     \
   static_cast<int32_t>(Simulator::Current()->Call(                             \
       bit_cast<int32_t, uword>(entry),                                         \
       Utils::Low32Bits(bit_cast<int64_t, double>(double_arg)),                 \
       Utils::High32Bits(bit_cast<int64_t, double>(double_arg)), 0, 0, false,   \
       true))
 #endif  // defined(HOST_ARCH_ARM)
 #endif  // defined(TARGET_ARCH_{ARM, ARM64})
 
-
 inline Dart_Handle NewString(const char* str) {
   return Dart_NewStringFromCString(str);
 }
 
-
 namespace dart {
 
 // Forward declarations.
 class Assembler;
 class CodeGenerator;
 class VirtualMemory;
 
-
 namespace bin {
 // Snapshot pieces if we link in a snapshot, otherwise initialized to NULL.
 extern const uint8_t* vm_snapshot_data;
 extern const uint8_t* vm_snapshot_instructions;
 extern const uint8_t* core_isolate_snapshot_data;
 extern const uint8_t* core_isolate_snapshot_instructions;
-}
-
+}  // namespace bin
 
 class TestCaseBase {
  public:
   explicit TestCaseBase(const char* name);
   virtual ~TestCaseBase() {}
 
   const char* name() const { return name_; }
 
   virtual void Run() = 0;
   void RunTest();
@@ skipping 57 matching lines @@
 
   static void AddTestLib(const char* url, const char* source);
   static const char* GetTestLib(const char* url);
 
  private:
   static Dart_Isolate CreateIsolate(const uint8_t* buffer, const char* name);
 
   RunEntry* const run_;
 };
 
-
 class RawTestCase : TestCaseBase {
  public:
   typedef void(RunEntry)();
 
   RawTestCase(RunEntry* run, const char* name) : TestCaseBase(name), run_(run) {
     raw_test_ = true;
   }
   virtual void Run();
 
  private:
   RunEntry* const run_;
 };
 
-
 class TestIsolateScope {
  public:
   TestIsolateScope() {
     isolate_ = reinterpret_cast<Isolate*>(TestCase::CreateTestIsolate());
     Dart_EnterScope();  // Create a Dart API scope for unit tests.
   }
   ~TestIsolateScope() {
     Dart_ExitScope();  // Exit the Dart API scope created for unit tests.
     ASSERT(isolate_ == Isolate::Current());
     Dart_ShutdownIsolate();
     isolate_ = NULL;
   }
   Isolate* isolate() const { return isolate_; }
 
  private:
   Isolate* isolate_;
 
   DISALLOW_COPY_AND_ASSIGN(TestIsolateScope);
 };
 
-
 template <typename T>
 struct is_void {
   static const bool value = false;
 };
 
-
 template <>
 struct is_void<void> {
   static const bool value = true;
 };
 
-
 template <typename T>
 struct is_double {
   static const bool value = false;
 };
 
-
 template <>
 struct is_double<double> {
   static const bool value = true;
 };
 
-
 class AssemblerTest {
  public:
   AssemblerTest(const char* name, Assembler* assembler)
       : name_(name), assembler_(assembler), code_(Code::ZoneHandle()) {
     ASSERT(name != NULL);
     ASSERT(assembler != NULL);
   }
   ~AssemblerTest() {}
 
   Assembler* assembler() const { return assembler_; }
@@ skipping 112 matching lines @@
   void Assemble();
 
  private:
   const char* name_;
   Assembler* assembler_;
   Code& code_;
 
   DISALLOW_COPY_AND_ASSIGN(AssemblerTest);
 };
 
-
 class CodeGenTest {
  public:
   explicit CodeGenTest(const char* name);
   ~CodeGenTest() {}
 
   // Accessors.
   const Function& function() const { return function_; }
 
   SequenceNode* node_sequence() const { return node_sequence_; }
 
   void set_default_parameter_values(ZoneGrowableArray<const Instance*>* value) {
     default_parameter_values_ = value;
   }
 
   // Compile test and set code in function.
   void Compile();
 
  private:
   Function& function_;
   SequenceNode* node_sequence_;
   ZoneGrowableArray<const Instance*>* default_parameter_values_;
 
   DISALLOW_COPY_AND_ASSIGN(CodeGenTest);
 };
 
-
 class CompilerTest : public AllStatic {
  public:
   // Test the Compiler::CompileScript functionality by checking the return
   // value to see if no parse errors were reported.
   static bool TestCompileScript(const Library& library, const Script& script);
 
   // Test the Compiler::CompileFunction functionality by checking the return
   // value to see if no parse errors were reported.
   static bool TestCompileFunction(const Function& function);
 };
@@ skipping 42 matching lines @@
       if (!value) {                                                            \
         dart::Expect(__FILE__, __LINE__)                                       \
             .Fail("expected True, but was '%s'\n", #handle);                   \
       }                                                                        \
     } else {                                                                   \
       dart::Expect(__FILE__, __LINE__)                                         \
           .Fail("expected True, but was '%s'\n", #handle);                     \
     }                                                                          \
   } while (0)
 
-
 // Elide a substring which starts with some prefix and ends with a ".
 //
 // This is used to remove non-deterministic or fragile substrings from
 // JSON output.
 //
 // For example:
 //
 //    prefix = "classes"
 //    in = "\"id\":\"classes/46\""
 //
 // Yields:
 //
 //    out = "\"id\":\"\""
 //
 void ElideJSONSubstring(const char* prefix, const char* in, char* out);
 
-
 template <typename T>
 class SetFlagScope : public ValueObject {
  public:
   SetFlagScope(T* flag, T value) : flag_(flag), original_value_(*flag) {
     *flag_ = value;
   }
 
   ~SetFlagScope() { *flag_ = original_value_; }
 
  private:
   T* flag_;
   T original_value_;
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_UNIT_TEST_H_