[formatting] Remove all double blank lines in WASM code.

test/unittests/wasm/ast-decoder-unittest.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "test/unittests/test-utils.h"
 
 #include "src/v8.h"
 
 #include "test/cctest/wasm/test-signatures.h"
 
@@ skipping 34 matching lines @@
 #define EXPECT_VERIFIES(env, x) Verify(kSuccess, env, x, x + arraysize(x))
 
 #define EXPECT_FAILURE(env, x) Verify(kError, env, x, x + arraysize(x))
 
 #define EXPECT_VERIFIES_INLINE(env, ...)                 \
   do {                                                   \
     static byte code[] = {__VA_ARGS__};                  \
     Verify(kSuccess, env, code, code + arraysize(code)); \
   } while (false)
 
-
 #define EXPECT_FAILURE_INLINE(env, ...)                \
   do {                                                 \
     static byte code[] = {__VA_ARGS__};                \
     Verify(kError, env, code, code + arraysize(code)); \
   } while (false)
 
 #define VERIFY(...)                                          \
   do {                                                       \
     static const byte code[] = {__VA_ARGS__};                \
     Verify(kSuccess, sigs.v_i(), code, code + sizeof(code)); \
@@ skipping 1077 matching lines @@
       FunctionSig sig(0, 1, &local_type);
       if (local_type == WasmOpcodes::LocalTypeFor(mem_type)) {
         EXPECT_VERIFIES(&sig, code);
       } else {
         EXPECT_FAILURE(&sig, code);
       }
     }
   }
 }
 
-
 namespace {
 // A helper for tests that require a module environment for functions and
 // globals.
 class TestModuleEnv : public ModuleEnv {
  public:
   TestModuleEnv() {
     instance = nullptr;
     module = &mod;
     linker = nullptr;
   }
@@ skipping 691 matching lines @@
 
   EXPECT_FAILURE_INLINE(
       sigs.i_i(),
       WASM_SELECT(WASM_GET_LOCAL(0), WASM_F64(0.25), WASM_GET_LOCAL(0)));
 
   EXPECT_FAILURE_INLINE(
       sigs.i_i(),
       WASM_SELECT(WASM_F32(9.9), WASM_GET_LOCAL(0), WASM_I64V_1(0)));
 }
 
-
 class WasmOpcodeLengthTest : public TestWithZone {
  public:
   WasmOpcodeLengthTest() : TestWithZone() {}
 };
 
 #define EXPECT_LENGTH(expected, opcode)                           \
   {                                                               \
     static const byte code[] = {opcode, 0, 0, 0, 0, 0, 0, 0, 0};  \
     EXPECT_EQ(expected, OpcodeLength(code, code + sizeof(code))); \
   }
 
 #define EXPECT_LENGTH_N(expected, ...)                            \
   {                                                               \
     static const byte code[] = {__VA_ARGS__};                     \
     EXPECT_EQ(expected, OpcodeLength(code, code + sizeof(code))); \
   }
 
 TEST_F(WasmOpcodeLengthTest, Statements) {
   EXPECT_LENGTH(1, kExprNop);
   EXPECT_LENGTH(1, kExprBlock);
   EXPECT_LENGTH(1, kExprLoop);
   EXPECT_LENGTH(1, kExprIf);
   EXPECT_LENGTH(1, kExprElse);
   EXPECT_LENGTH(1, kExprEnd);
   EXPECT_LENGTH(1, kExprSelect);
   EXPECT_LENGTH(3, kExprBr);
   EXPECT_LENGTH(3, kExprBrIf);
 }
 
-
 TEST_F(WasmOpcodeLengthTest, MiscExpressions) {
   EXPECT_LENGTH(2, kExprI8Const);
   EXPECT_LENGTH(5, kExprF32Const);
   EXPECT_LENGTH(9, kExprF64Const);
   EXPECT_LENGTH(2, kExprGetLocal);
   EXPECT_LENGTH(2, kExprSetLocal);
   EXPECT_LENGTH(2, kExprLoadGlobal);
   EXPECT_LENGTH(2, kExprStoreGlobal);
   EXPECT_LENGTH(3, kExprCallFunction);
   EXPECT_LENGTH(3, kExprCallImport);
@@ skipping 53 matching lines @@
   EXPECT_LENGTH(3, kExprI32StoreMem16);
   EXPECT_LENGTH(3, kExprI32StoreMem);
   EXPECT_LENGTH(3, kExprI64StoreMem8);
   EXPECT_LENGTH(3, kExprI64StoreMem16);
   EXPECT_LENGTH(3, kExprI64StoreMem32);
   EXPECT_LENGTH(3, kExprI64StoreMem);
   EXPECT_LENGTH(3, kExprF32StoreMem);
   EXPECT_LENGTH(3, kExprF64StoreMem);
 }
 
-
 TEST_F(WasmOpcodeLengthTest, MiscMemExpressions) {
   EXPECT_LENGTH(1, kExprMemorySize);
   EXPECT_LENGTH(1, kExprGrowMemory);
 }
 
-
 TEST_F(WasmOpcodeLengthTest, SimpleExpressions) {
   EXPECT_LENGTH(1, kExprI32Add);
   EXPECT_LENGTH(1, kExprI32Sub);
   EXPECT_LENGTH(1, kExprI32Mul);
   EXPECT_LENGTH(1, kExprI32DivS);
   EXPECT_LENGTH(1, kExprI32DivU);
   EXPECT_LENGTH(1, kExprI32RemS);
   EXPECT_LENGTH(1, kExprI32RemU);
   EXPECT_LENGTH(1, kExprI32And);
   EXPECT_LENGTH(1, kExprI32Ior);
@@ skipping 101 matching lines @@
   EXPECT_LENGTH(1, kExprF64SConvertI32);
   EXPECT_LENGTH(1, kExprF64UConvertI32);
   EXPECT_LENGTH(1, kExprF64SConvertI64);
   EXPECT_LENGTH(1, kExprF64UConvertI64);
   EXPECT_LENGTH(1, kExprF64ConvertF32);
   EXPECT_LENGTH(1, kExprF64ReinterpretI64);
   EXPECT_LENGTH(1, kExprI32ReinterpretF32);
   EXPECT_LENGTH(1, kExprI64ReinterpretF64);
 }
 
-
 class WasmOpcodeArityTest : public TestWithZone {
  public:
   WasmOpcodeArityTest() : TestWithZone() {}
 };
 
 #define EXPECT_ARITY(expected, ...)                              \
   {                                                              \
     static const byte code[] = {__VA_ARGS__};                    \
     EXPECT_EQ(expected, OpcodeArity(code, code + sizeof(code))); \
   }
@@ skipping 22 matching lines @@
   EXPECT_ARITY(1, kExprBr, ARITY_1);
   EXPECT_ARITY(2, kExprBrIf, ARITY_1);
   EXPECT_ARITY(2, kExprBrTable, ARITY_1);
 
   {
     EXPECT_ARITY(0, kExprReturn, ARITY_0);
     EXPECT_ARITY(1, kExprReturn, ARITY_1);
   }
 }
 
-
 TEST_F(WasmOpcodeArityTest, Misc) {
   EXPECT_ARITY(0, kExprI8Const);
   EXPECT_ARITY(0, kExprI32Const);
   EXPECT_ARITY(0, kExprF32Const);
   EXPECT_ARITY(0, kExprI64Const);
   EXPECT_ARITY(0, kExprF64Const);
   EXPECT_ARITY(0, kExprGetLocal);
   EXPECT_ARITY(1, kExprSetLocal);
   EXPECT_ARITY(0, kExprLoadGlobal);
   EXPECT_ARITY(1, kExprStoreGlobal);
 }
 
-
 TEST_F(WasmOpcodeArityTest, Calls) {
   {
     EXPECT_ARITY(2, kExprCallFunction, 2, 0);
     EXPECT_ARITY(2, kExprCallImport, 2, 0);
     EXPECT_ARITY(3, kExprCallIndirect, 2, 0);
 
     EXPECT_ARITY(1, kExprBr, ARITY_1);
     EXPECT_ARITY(2, kExprBrIf, ARITY_1);
     EXPECT_ARITY(2, kExprBrTable, ARITY_1);
 
@@ skipping 10 matching lines @@
     EXPECT_ARITY(1, kExprBr, ARITY_1);
     EXPECT_ARITY(2, kExprBrIf, ARITY_1);
     EXPECT_ARITY(2, kExprBrTable, ARITY_1);
 
     EXPECT_ARITY(0, kExprBr, ARITY_0);
     EXPECT_ARITY(1, kExprBrIf, ARITY_0);
     EXPECT_ARITY(1, kExprBrTable, ARITY_0);
   }
 }
 
-
 TEST_F(WasmOpcodeArityTest, LoadsAndStores) {
   EXPECT_ARITY(1, kExprI32LoadMem8S);
   EXPECT_ARITY(1, kExprI32LoadMem8U);
   EXPECT_ARITY(1, kExprI32LoadMem16S);
   EXPECT_ARITY(1, kExprI32LoadMem16U);
   EXPECT_ARITY(1, kExprI32LoadMem);
 
   EXPECT_ARITY(1, kExprI64LoadMem8S);
   EXPECT_ARITY(1, kExprI64LoadMem8U);
   EXPECT_ARITY(1, kExprI64LoadMem16S);
   EXPECT_ARITY(1, kExprI64LoadMem16U);
   EXPECT_ARITY(1, kExprI64LoadMem32S);
   EXPECT_ARITY(1, kExprI64LoadMem32U);
   EXPECT_ARITY(1, kExprI64LoadMem);
   EXPECT_ARITY(1, kExprF32LoadMem);
   EXPECT_ARITY(1, kExprF64LoadMem);
 
   EXPECT_ARITY(2, kExprI32StoreMem8);
   EXPECT_ARITY(2, kExprI32StoreMem16);
   EXPECT_ARITY(2, kExprI32StoreMem);
   EXPECT_ARITY(2, kExprI64StoreMem8);
   EXPECT_ARITY(2, kExprI64StoreMem16);
   EXPECT_ARITY(2, kExprI64StoreMem32);
   EXPECT_ARITY(2, kExprI64StoreMem);
   EXPECT_ARITY(2, kExprF32StoreMem);
   EXPECT_ARITY(2, kExprF64StoreMem);
 }
 
-
 TEST_F(WasmOpcodeArityTest, MiscMemExpressions) {
   EXPECT_ARITY(0, kExprMemorySize);
   EXPECT_ARITY(1, kExprGrowMemory);
 }
 
-
 TEST_F(WasmOpcodeArityTest, SimpleExpressions) {
   EXPECT_ARITY(2, kExprI32Add);
   EXPECT_ARITY(2, kExprI32Sub);
   EXPECT_ARITY(2, kExprI32Mul);
   EXPECT_ARITY(2, kExprI32DivS);
   EXPECT_ARITY(2, kExprI32DivU);
   EXPECT_ARITY(2, kExprI32RemS);
   EXPECT_ARITY(2, kExprI32RemU);
   EXPECT_ARITY(2, kExprI32And);
   EXPECT_ARITY(2, kExprI32Ior);
@@ skipping 224 matching lines @@
   size_t pos = 0;
   pos = ExpectRun(map, pos, kAstF32, 5);
   pos = ExpectRun(map, pos, kAstI32, 1337);
   pos = ExpectRun(map, pos, kAstI64, 212);
   delete[] data;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8