[wasm] Fix more -Wsign-compare warnings.

test/unittests/wasm/module-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/handles.h"
 #include "src/objects-inl.h"
 #include "src/wasm/module-decoder.h"
 #include "src/wasm/wasm-macro-gen.h"
@@ skipping 174 matching lines @@
       1,
       kLocalI32,                 // local type
       0,                         // immutable
       WASM_INIT_EXPR_I32V_1(13)  // init
   };
 
   {
     // Should decode to exactly one global.
     ModuleResult result = DecodeModule(data, data + sizeof(data));
     EXPECT_OK(result);
-    EXPECT_EQ(1, result.val->globals.size());
-    EXPECT_EQ(0, result.val->functions.size());
-    EXPECT_EQ(0, result.val->data_segments.size());
+    EXPECT_EQ(1u, result.val->globals.size());
+    EXPECT_EQ(0u, result.val->functions.size());
+    EXPECT_EQ(0u, result.val->data_segments.size());
 
     const WasmGlobal* global = &result.val->globals.back();
 
     EXPECT_EQ(kAstI32, global->type);
-    EXPECT_EQ(0, global->offset);
+    EXPECT_EQ(0u, global->offset);
     EXPECT_FALSE(global->mutability);
     EXPECT_EQ(WasmInitExpr::kI32Const, global->init.kind);
     EXPECT_EQ(13, global->init.val.i32_const);
 
     if (result.val) delete result.val;
   }
 
   EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
 }
 
@@ skipping 133 matching lines @@
       WASM_INIT_EXPR_F32(22.0),
       kLocalF64,  // type
       1,          // mutable
       WASM_INIT_EXPR_F64(23.0),
   };
 
   {
     // Should decode to exactly two globals.
     ModuleResult result = DecodeModule(data, data + sizeof(data));
     EXPECT_OK(result);
-    EXPECT_EQ(2, result.val->globals.size());
-    EXPECT_EQ(0, result.val->functions.size());
-    EXPECT_EQ(0, result.val->data_segments.size());
+    EXPECT_EQ(2u, result.val->globals.size());
+    EXPECT_EQ(0u, result.val->functions.size());
+    EXPECT_EQ(0u, result.val->data_segments.size());
 
     const WasmGlobal* g0 = &result.val->globals[0];
 
     EXPECT_EQ(kAstF32, g0->type);
-    EXPECT_EQ(0, g0->offset);
+    EXPECT_EQ(0u, g0->offset);
     EXPECT_FALSE(g0->mutability);
     EXPECT_EQ(WasmInitExpr::kF32Const, g0->init.kind);
 
     const WasmGlobal* g1 = &result.val->globals[1];
 
     EXPECT_EQ(kAstF64, g1->type);
-    EXPECT_EQ(8, g1->offset);
+    EXPECT_EQ(8u, g1->offset);
     EXPECT_TRUE(g1->mutability);
     EXPECT_EQ(WasmInitExpr::kF64Const, g1->init.kind);
 
     if (result.val) delete result.val;
   }
 
   EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
 }
 
 TEST_F(WasmModuleVerifyTest, OneSignature) {
@@ skipping 14 matching lines @@
       SECTION(Type, 1 + SIZEOF_SIG_ENTRY_v_v + SIZEOF_SIG_ENTRY_x_x +
                         SIZEOF_SIG_ENTRY_x_xx),         // --
       3,                                                // --
       SIG_ENTRY_v_v,                                    // void -> void
       SIG_ENTRY_x_x(kLocalI32, kLocalF32),              // f32 -> i32
       SIG_ENTRY_x_xx(kLocalI32, kLocalF64, kLocalF64),  // f64,f64 -> i32
   };
 
   ModuleResult result = DecodeModule(data, data + sizeof(data));
   EXPECT_OK(result);
-  EXPECT_EQ(3, result.val->signatures.size());
+  EXPECT_EQ(3u, result.val->signatures.size());
   if (result.val->signatures.size() == 3) {
-    EXPECT_EQ(0, result.val->signatures[0]->return_count());
-    EXPECT_EQ(1, result.val->signatures[1]->return_count());
-    EXPECT_EQ(1, result.val->signatures[2]->return_count());
+    EXPECT_EQ(0u, result.val->signatures[0]->return_count());
+    EXPECT_EQ(1u, result.val->signatures[1]->return_count());
+    EXPECT_EQ(1u, result.val->signatures[2]->return_count());
 
-    EXPECT_EQ(0, result.val->signatures[0]->parameter_count());
-    EXPECT_EQ(1, result.val->signatures[1]->parameter_count());
-    EXPECT_EQ(2, result.val->signatures[2]->parameter_count());
+    EXPECT_EQ(0u, result.val->signatures[0]->parameter_count());
+    EXPECT_EQ(1u, result.val->signatures[1]->parameter_count());
+    EXPECT_EQ(2u, result.val->signatures[2]->parameter_count());
   }
   if (result.val) delete result.val;
 
   EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
 }
 
 TEST_F(WasmModuleVerifyTest, DataSegmentWithImmutableImportedGlobal) {
   // Import 2 globals so that we can initialize data with a global index != 0.
   const byte data[] = {
       SECTION(Import, 15),  // section header
@@ skipping 23 matching lines @@
       WASM_INIT_EXPR_GLOBAL(1),  // dest addr
       U32V_1(3),                 // source size
       'a',
       'b',
       'c'  // data bytes
   };
   ModuleResult result = DecodeModule(data, data + sizeof(data));
   EXPECT_OK(result);
   WasmInitExpr expr = result.val->data_segments.back().dest_addr;
   EXPECT_EQ(WasmInitExpr::kGlobalIndex, expr.kind);
-  EXPECT_EQ(1, expr.val.global_index);
+  EXPECT_EQ(1u, expr.val.global_index);
   if (result.val) delete result.val;
 }
 
 TEST_F(WasmModuleVerifyTest, DataSegmentWithMutableImportedGlobal) {
   // Only an immutable imported global can be used as an init_expr.
   const byte data[] = {
       SECTION(Import, 8),  // section header
       1,                   // number of imports
       NAME_LENGTH(1),      // --
       'm',                 // module name
@@ skipping 58 matching lines @@
       U32V_1(3),                       // source size
       'a',
       'b',
       'c'  // data bytes
   };
 
   {
     EXPECT_VERIFIES(data);
     ModuleResult result = DecodeModule(data, data + sizeof(data));
     EXPECT_OK(result);
-    EXPECT_EQ(0, result.val->globals.size());
-    EXPECT_EQ(0, result.val->functions.size());
-    EXPECT_EQ(1, result.val->data_segments.size());
+    EXPECT_EQ(0u, result.val->globals.size());
+    EXPECT_EQ(0u, result.val->functions.size());
+    EXPECT_EQ(1u, result.val->data_segments.size());
 
     const WasmDataSegment* segment = &result.val->data_segments.back();
 
     EXPECT_EQ(WasmInitExpr::kI32Const, segment->dest_addr.kind);
     EXPECT_EQ(0x9bbaa, segment->dest_addr.val.i32_const);
     EXPECT_EQ(kDataSegmentSourceOffset, segment->source_offset);
-    EXPECT_EQ(3, segment->source_size);
+    EXPECT_EQ(3u, segment->source_size);
 
     if (result.val) delete result.val;
   }
 
   EXPECT_OFF_END_FAILURE(data, 14, sizeof(data));
 }
 
 TEST_F(WasmModuleVerifyTest, TwoDataSegments) {
   const byte kDataSegment0SourceOffset = 24;
   const byte kDataSegment1SourceOffset = kDataSegment0SourceOffset + 11;
@@ skipping 24 matching lines @@
       6,
       7,
       8,
       9,
       10  // data bytes
   };
 
   {
     ModuleResult result = DecodeModule(data, data + sizeof(data));
     EXPECT_OK(result);
-    EXPECT_EQ(0, result.val->globals.size());
-    EXPECT_EQ(0, result.val->functions.size());
-    EXPECT_EQ(2, result.val->data_segments.size());
+    EXPECT_EQ(0u, result.val->globals.size());
+    EXPECT_EQ(0u, result.val->functions.size());
+    EXPECT_EQ(2u, result.val->data_segments.size());
 
     const WasmDataSegment* s0 = &result.val->data_segments[0];
     const WasmDataSegment* s1 = &result.val->data_segments[1];
 
     EXPECT_EQ(WasmInitExpr::kI32Const, s0->dest_addr.kind);
     EXPECT_EQ(0x7ffee, s0->dest_addr.val.i32_const);
     EXPECT_EQ(kDataSegment0SourceOffset, s0->source_offset);
-    EXPECT_EQ(4, s0->source_size);
+    EXPECT_EQ(4u, s0->source_size);
 
     EXPECT_EQ(WasmInitExpr::kI32Const, s1->dest_addr.kind);
     EXPECT_EQ(0x6ddcc, s1->dest_addr.val.i32_const);
     EXPECT_EQ(kDataSegment1SourceOffset, s1->source_offset);
-    EXPECT_EQ(10, s1->source_size);
+    EXPECT_EQ(10u, s1->source_size);
 
     if (result.val) delete result.val;
   }
 
   EXPECT_OFF_END_FAILURE(data, 14, sizeof(data));
 }
 
 TEST_F(WasmModuleVerifyTest, DataWithoutMemory) {
   const byte data[] = {
       SECTION(Data, 11),
@@ skipping 50 matching lines @@
       // sig#0 ---------------------------------------------------------------
       SIGNATURES_SECTION_VOID_VOID,
       // funcs ---------------------------------------------------------------
       ONE_EMPTY_FUNCTION,
       // table declaration ---------------------------------------------------
       SECTION(Table, 4), ENTRY_COUNT(1), kWasmAnyFunctionTypeForm, 0, 1};
 
   ModuleResult result = DecodeModule(data, data + sizeof(data));
   EXPECT_OK(result);
   if (result.ok()) {
-    EXPECT_EQ(1, result.val->signatures.size());
-    EXPECT_EQ(1, result.val->functions.size());
-    EXPECT_EQ(1, result.val->function_tables.size());
-    EXPECT_EQ(1, result.val->function_tables[0].min_size);
+    EXPECT_EQ(1u, result.val->signatures.size());
+    EXPECT_EQ(1u, result.val->functions.size());
+    EXPECT_EQ(1u, result.val->function_tables.size());
+    EXPECT_EQ(1u, result.val->function_tables[0].min_size);
   }
   if (result.val) delete result.val;
 }
 
 TEST_F(WasmModuleVerifyTest, OneIndirectFunction_one_entry) {
   static const byte data[] = {
       // sig#0 ---------------------------------------------------------------
       SIGNATURES_SECTION_VOID_VOID,
       // funcs ---------------------------------------------------------------
       ONE_EMPTY_FUNCTION,
       // table declaration ---------------------------------------------------
       SECTION(Table, 4), ENTRY_COUNT(1), kWasmAnyFunctionTypeForm, 0, 1,
       // elements ------------------------------------------------------------
       SECTION(Element, 7),
       1,  // entry count
       TABLE_INDEX(0), WASM_INIT_EXPR_I32V_1(0),
       1,  // elements count
       FUNC_INDEX(0)};
 
   ModuleResult result = DecodeModule(data, data + sizeof(data));
   EXPECT_OK(result);
   if (result.ok()) {
-    EXPECT_EQ(1, result.val->signatures.size());
-    EXPECT_EQ(1, result.val->functions.size());
-    EXPECT_EQ(1, result.val->function_tables.size());
-    EXPECT_EQ(1, result.val->function_tables[0].min_size);
+    EXPECT_EQ(1u, result.val->signatures.size());
+    EXPECT_EQ(1u, result.val->functions.size());
+    EXPECT_EQ(1u, result.val->function_tables.size());
+    EXPECT_EQ(1u, result.val->function_tables[0].min_size);
   }
   if (result.val) delete result.val;
 }
 
 TEST_F(WasmModuleVerifyTest, MultipleIndirectFunctions) {
   static const byte data[] = {
       // sig#0 -------------------------------------------------------
       SECTION(Type, 1 + SIZEOF_SIG_ENTRY_v_v + SIZEOF_SIG_ENTRY_v_x),
       2,                         // --
       SIG_ENTRY_v_v,             // void -> void
@@ skipping 13 matching lines @@
       FUNC_INDEX(3),  // --
       FUNC_INDEX(0),  // --
       FUNC_INDEX(1),  // --
       FUNC_INDEX(2),  // --
       FUNC_INDEX(3),  // --
       FOUR_EMPTY_BODIES};
 
   ModuleResult result = DecodeModule(data, data + sizeof(data));
   EXPECT_OK(result);
   if (result.ok()) {
-    EXPECT_EQ(2, result.val->signatures.size());
-    EXPECT_EQ(4, result.val->functions.size());
-    EXPECT_EQ(1, result.val->function_tables.size());
-    EXPECT_EQ(8, result.val->function_tables[0].min_size);
+    EXPECT_EQ(2u, result.val->signatures.size());
+    EXPECT_EQ(4u, result.val->functions.size());
+    EXPECT_EQ(1u, result.val->function_tables.size());
+    EXPECT_EQ(8u, result.val->function_tables[0].min_size);
   }
   if (result.val) delete result.val;
 }
 
 TEST_F(WasmModuleVerifyTest, IndirectFunctionNoFunctions) {
   static const byte data[] = {
       // sig#0 -------------------------------------------------------
       SIGNATURES_SECTION_VOID_VOID,
       // indirect table ----------------------------------------------
       SECTION(Table, 4), ENTRY_COUNT(1), 1, 0, 0,
@@ skipping 18 matching lines @@
 class WasmSignatureDecodeTest : public TestWithZone {};
 
 TEST_F(WasmSignatureDecodeTest, Ok_v_v) {
   static const byte data[] = {SIG_ENTRY_v_v};
   v8::internal::AccountingAllocator allocator;
   Zone zone(&allocator, ZONE_NAME);
   FunctionSig* sig =
       DecodeWasmSignatureForTesting(&zone, data, data + sizeof(data));
 
   EXPECT_TRUE(sig != nullptr);
-  EXPECT_EQ(0, sig->parameter_count());
-  EXPECT_EQ(0, sig->return_count());
+  EXPECT_EQ(0u, sig->parameter_count());
+  EXPECT_EQ(0u, sig->return_count());
 }
 
 TEST_F(WasmSignatureDecodeTest, Ok_t_v) {
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     LocalTypePair ret_type = kLocalTypes[i];
     const byte data[] = {SIG_ENTRY_x(ret_type.code)};
     FunctionSig* sig =
         DecodeWasmSignatureForTesting(zone(), data, data + sizeof(data));
 
     EXPECT_TRUE(sig != nullptr);
-    EXPECT_EQ(0, sig->parameter_count());
-    EXPECT_EQ(1, sig->return_count());
+    EXPECT_EQ(0u, sig->parameter_count());
+    EXPECT_EQ(1u, sig->return_count());
     EXPECT_EQ(ret_type.type, sig->GetReturn());
   }
 }
 
 TEST_F(WasmSignatureDecodeTest, Ok_v_t) {
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     LocalTypePair param_type = kLocalTypes[i];
     const byte data[] = {SIG_ENTRY_v_x(param_type.code)};
     FunctionSig* sig =
         DecodeWasmSignatureForTesting(zone(), data, data + sizeof(data));
 
     EXPECT_TRUE(sig != nullptr);
-    EXPECT_EQ(1, sig->parameter_count());
-    EXPECT_EQ(0, sig->return_count());
+    EXPECT_EQ(1u, sig->parameter_count());
+    EXPECT_EQ(0u, sig->return_count());
     EXPECT_EQ(param_type.type, sig->GetParam(0));
   }
 }
 
 TEST_F(WasmSignatureDecodeTest, Ok_t_t) {
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     LocalTypePair ret_type = kLocalTypes[i];
     for (size_t j = 0; j < arraysize(kLocalTypes); j++) {
       LocalTypePair param_type = kLocalTypes[j];
       const byte data[] = {SIG_ENTRY_x_x(ret_type.code, param_type.code)};
       FunctionSig* sig =
           DecodeWasmSignatureForTesting(zone(), data, data + sizeof(data));
 
       EXPECT_TRUE(sig != nullptr);
-      EXPECT_EQ(1, sig->parameter_count());
-      EXPECT_EQ(1, sig->return_count());
+      EXPECT_EQ(1u, sig->parameter_count());
+      EXPECT_EQ(1u, sig->return_count());
       EXPECT_EQ(param_type.type, sig->GetParam(0));
       EXPECT_EQ(ret_type.type, sig->GetReturn());
     }
   }
 }
 
 TEST_F(WasmSignatureDecodeTest, Ok_i_tt) {
   for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
     LocalTypePair p0_type = kLocalTypes[i];
     for (size_t j = 0; j < arraysize(kLocalTypes); j++) {
       LocalTypePair p1_type = kLocalTypes[j];
       const byte data[] = {
           SIG_ENTRY_x_xx(kLocalI32, p0_type.code, p1_type.code)};
       FunctionSig* sig =
           DecodeWasmSignatureForTesting(zone(), data, data + sizeof(data));
 
       EXPECT_TRUE(sig != nullptr);
-      EXPECT_EQ(2, sig->parameter_count());
-      EXPECT_EQ(1, sig->return_count());
+      EXPECT_EQ(2u, sig->parameter_count());
+      EXPECT_EQ(1u, sig->return_count());
       EXPECT_EQ(p0_type.type, sig->GetParam(0));
       EXPECT_EQ(p1_type.type, sig->GetParam(1));
     }
   }
 }
 
 TEST_F(WasmSignatureDecodeTest, Fail_off_end) {
   byte data[256];
   for (int p = 0; p <= 255; p = p + 1 + p * 3) {
     for (int i = 0; i <= p; i++) data[i] = kLocalI32;
@@ skipping 55 matching lines @@
       kLocalF64,  // --
       kExprNop    // body
   };
 
   FunctionResult result =
       DecodeWasmFunction(isolate(), zone(), nullptr, data, data + sizeof(data));
   EXPECT_OK(result);
 
   if (result.val && result.ok()) {
     WasmFunction* function = result.val;
-    EXPECT_EQ(0, function->sig->parameter_count());
-    EXPECT_EQ(0, function->sig->return_count());
-    EXPECT_EQ(0, function->name_offset);
-    EXPECT_EQ(SIZEOF_SIG_ENTRY_v_v, function->code_start_offset);
+    EXPECT_EQ(0u, function->sig->parameter_count());
+    EXPECT_EQ(0u, function->sig->return_count());
+    EXPECT_EQ(0u, function->name_offset);
+    EXPECT_EQ(static_cast<uint32_t>(SIZEOF_SIG_ENTRY_v_v),
+              function->code_start_offset);
     EXPECT_EQ(sizeof(data), function->code_end_offset);
     // TODO(titzer): verify encoding of local declarations
   }
 
   if (result.val) delete result.val;
 }
 
 TEST_F(WasmModuleVerifyTest, SectionWithoutNameLength) {
   const byte data[] = {1};
   EXPECT_FAILURE(data);
@@ skipping 81 matching lines @@
       0,  // one byte section
       SECTION(Global, 6),
       1,
       kLocalI32,                  // memory type
       0,                          // exported
       WASM_INIT_EXPR_I32V_1(33),  // init
   };
   ModuleResult result = DecodeModule(data, data + sizeof(data));
   EXPECT_OK(result);
 
-  EXPECT_EQ(1, result.val->globals.size());
-  EXPECT_EQ(0, result.val->functions.size());
-  EXPECT_EQ(0, result.val->data_segments.size());
+  EXPECT_EQ(1u, result.val->globals.size());
+  EXPECT_EQ(0u, result.val->functions.size());
+  EXPECT_EQ(0u, result.val->data_segments.size());
 
   const WasmGlobal* global = &result.val->globals.back();
 
   EXPECT_EQ(kAstI32, global->type);
-  EXPECT_EQ(0, global->offset);
+  EXPECT_EQ(0u, global->offset);
 
   if (result.val) delete result.val;
 }
 
 TEST_F(WasmModuleVerifyTest, ImportTable_empty) {
   static const byte data[] = {SECTION(Type, 1), 0, SECTION(Import, 1), 0};
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, ImportTable_nosigs1) {
@@ skipping 106 matching lines @@
 TEST_F(WasmModuleVerifyTest, ExportTable_empty1) {
   static const byte data[] = {                               // signatures
                               SIGNATURES_SECTION_VOID_VOID,  // --
                               ONE_EMPTY_FUNCTION, SECTION(Export, 1),  // --
                               0,                                       // --
                               ONE_EMPTY_BODY};
 
   ModuleResult result = DecodeModule(data, data + sizeof(data));
   EXPECT_OK(result);
 
-  EXPECT_EQ(1, result.val->functions.size());
-  EXPECT_EQ(0, result.val->export_table.size());
+  EXPECT_EQ(1u, result.val->functions.size());
+  EXPECT_EQ(0u, result.val->export_table.size());
 
   if (result.val) delete result.val;
 }
 
 TEST_F(WasmModuleVerifyTest, ExportTable_empty2) {
   static const byte data[] = {
       SECTION(Type, 1), 0, SECTION(Export, 1), 0  // --
   };
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, ExportTable_NoFunctions2) {
   static const byte data[] = {SECTION(Export, 1), 0};
   EXPECT_VERIFIES(data);
 }
 
 TEST_F(WasmModuleVerifyTest, ExportTableOne) {
   static const byte data[] = {// signatures
                               SIGNATURES_SECTION_VOID_VOID,
                               ONE_EMPTY_FUNCTION,
                               SECTION(Export, 4),
                               1,                  // exports
                               NO_NAME,            // --
                               kExternalFunction,  // --
                               FUNC_INDEX(0),      // --
                               ONE_EMPTY_BODY};
   ModuleResult result = DecodeModule(data, data + sizeof(data));
   EXPECT_OK(result);
 
-  EXPECT_EQ(1, result.val->functions.size());
-  EXPECT_EQ(1, result.val->export_table.size());
+  EXPECT_EQ(1u, result.val->functions.size());
+  EXPECT_EQ(1u, result.val->export_table.size());
 
   if (result.val) delete result.val;
 }
 
 TEST_F(WasmModuleVerifyTest, ExportNameWithInvalidStringLength) {
   static const byte data[] = {// signatures
                               SIGNATURES_SECTION_VOID_VOID,
                               ONE_EMPTY_FUNCTION,
                               SECTION(Export, 12),
                               1,                  // exports
@@ skipping 22 matching lines @@
                               'n',
                               'o',
                               'm',                // --
                               kExternalFunction,  // --
                               FUNC_INDEX(0),      // --
                               ONE_EMPTY_BODY};
 
   ModuleResult result = DecodeModule(data, data + sizeof(data));
   EXPECT_OK(result);
 
-  EXPECT_EQ(1, result.val->functions.size());
-  EXPECT_EQ(2, result.val->export_table.size());
+  EXPECT_EQ(1u, result.val->functions.size());
+  EXPECT_EQ(2u, result.val->export_table.size());
 
   if (result.val) delete result.val;
 }
 
 TEST_F(WasmModuleVerifyTest, ExportTableThree) {
   static const byte data[] = {// signatures
                               SIGNATURES_SECTION_VOID_VOID,
                               THREE_EMPTY_FUNCTIONS,
                               SECTION(Export, 13),
                               3,  // exports
                               NAME_LENGTH(1),
                               'a',  // --
                               kExternalFunction,
                               FUNC_INDEX(0),  // --
                               NAME_LENGTH(1),
                               'b',  // --
                               kExternalFunction,
                               FUNC_INDEX(1),  // --
                               NAME_LENGTH(1),
                               'c',  // --
                               kExternalFunction,
                               FUNC_INDEX(2),  // --
                               THREE_EMPTY_BODIES};
   ModuleResult result = DecodeModule(data, data + sizeof(data));
   EXPECT_OK(result);
 
-  EXPECT_EQ(3, result.val->functions.size());
-  EXPECT_EQ(3, result.val->export_table.size());
+  EXPECT_EQ(3u, result.val->functions.size());
+  EXPECT_EQ(3u, result.val->export_table.size());
 
   if (result.val) delete result.val;
 }
 
 TEST_F(WasmModuleVerifyTest, ExportTableThreeOne) {
   for (int i = 0; i < 6; i++) {
     const byte data[] = {// signatures
                          SIGNATURES_SECTION_VOID_VOID,
                          THREE_EMPTY_FUNCTIONS,
                          SECTION(Export, 6),
@@ skipping 204 matching lines @@
       SECTION(Unknown, 4), 1, 'X', 17,  18,                      // --
       SECTION(Unknown, 9), 3, 'f', 'o', 'o', 5,   6,   7, 8, 9,  // --
       SECTION(Unknown, 8), 5, 'o', 't', 'h', 'e', 'r', 7, 8,     // --
   };
   EXPECT_VERIFIES(data);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8