[wasm][test] Various test cleanups

Changes:
- Remove an obsolete TODO from wasm-module-builder.
- Replace CHECK with gTest's EXPECT in unittests.
- Remove setting of --experimental-wasm-liftoff-extern-ref in wasm-gc.
- Test test-gc/JSAccess with Liftoff.
- Remove useless #undef's from module-decoder-unittest.

Change-Id: I11b4a3dde9683cc9c7d1eb89b1a63e1859505aad
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2659063
Commit-Queue: Manos Koukoutos <manoskouk@chromium.org>
Reviewed-by: Jakob Kummerow <jkummerow@chromium.org>
Cr-Commit-Position: refs/heads/master@{#72455}

src/wasm/wasm-module-builder.cc

@@ -504,8 +504,6 @@ void WriteGlobalInitializer(ZoneBuffer* buffer, const WasmInitExpr& init,
     case WasmInitExpr::kRttSub:
       // The operand to rtt.sub must be emitted first.
       WriteGlobalInitializer(buffer, *init.operand(), kWasmBottom);
-      // TODO(7748): If immediates for rtts remain in the standard, adapt this
-      // to emit them.
       STATIC_ASSERT((kExprRttSub >> 8) == kGCPrefix);
       buffer->write_u8(kGCPrefix);
       buffer->write_u8(static_cast<uint8_t>(kExprRttSub));

test/cctest/wasm/test-gc.cc

@@ -204,7 +204,6 @@ ValueType optref(uint32_t type_index) {
 
 WASM_COMPILED_EXEC_TEST(WasmBasicStruct) {
   WasmGCTester tester(execution_tier);
-  FLAG_experimental_liftoff_extern_ref = true;
 
   const byte type_index =
       tester.DefineStruct({F(kWasmI32, true), F(kWasmI32, true)});
@@ -277,7 +276,6 @@ WASM_COMPILED_EXEC_TEST(WasmBasicStruct) {
 // struct refs types in globals and if-results.
 WASM_COMPILED_EXEC_TEST(WasmRefAsNonNull) {
   WasmGCTester tester(execution_tier);
-  FLAG_experimental_liftoff_extern_ref = true;
   const byte type_index =
       tester.DefineStruct({F(kWasmI32, true), F(kWasmI32, true)});
   ValueType kRefTypes[] = {ref(type_index)};
@@ -308,7 +306,6 @@ WASM_COMPILED_EXEC_TEST(WasmRefAsNonNull) {
 
 WASM_COMPILED_EXEC_TEST(WasmBrOnNull) {
   WasmGCTester tester(execution_tier);
-  FLAG_experimental_liftoff_extern_ref = true;
   const byte type_index =
       tester.DefineStruct({F(kWasmI32, true), F(kWasmI32, true)});
   ValueType kRefTypes[] = {ref(type_index)};
@@ -346,7 +343,6 @@ WASM_COMPILED_EXEC_TEST(WasmBrOnNull) {
 
 WASM_COMPILED_EXEC_TEST(BrOnCast) {
   WasmGCTester tester(execution_tier);
-  FLAG_experimental_liftoff_extern_ref = true;
   ValueType kDataRefNull = ValueType::Ref(HeapType::kData, kNullable);
   const byte type_index = tester.DefineStruct({F(kWasmI32, true)});
   const byte other_type_index = tester.DefineStruct({F(kWasmF32, true)});
@@ -418,7 +414,6 @@ WASM_COMPILED_EXEC_TEST(BrOnCast) {
 
 WASM_COMPILED_EXEC_TEST(WasmRefEq) {
   WasmGCTester tester(execution_tier);
-  FLAG_experimental_liftoff_extern_ref = true;
   byte type_index = tester.DefineStruct({F(kWasmI32, true), F(kWasmI32, true)});
   ValueType kRefTypes[] = {ref(type_index)};
   ValueType kOptRefType = optref(type_index);
@@ -458,7 +453,6 @@ WASM_COMPILED_EXEC_TEST(WasmRefEq) {
 
 WASM_COMPILED_EXEC_TEST(WasmPackedStructU) {
   WasmGCTester tester(execution_tier);
-  FLAG_experimental_liftoff_extern_ref = true;
 
   const byte type_index = tester.DefineStruct(
       {F(kWasmI8, true), F(kWasmI16, true), F(kWasmI32, true)});
@@ -496,7 +490,6 @@ WASM_COMPILED_EXEC_TEST(WasmPackedStructU) {
 
 WASM_COMPILED_EXEC_TEST(WasmPackedStructS) {
   WasmGCTester tester(execution_tier);
-  FLAG_experimental_liftoff_extern_ref = true;
 
   const byte type_index = tester.DefineStruct(
       {F(kWasmI8, true), F(kWasmI16, true), F(kWasmI32, true)});
@@ -614,7 +607,6 @@ TEST(WasmLetInstruction) {
 
 WASM_COMPILED_EXEC_TEST(WasmBasicArray) {
   WasmGCTester tester(execution_tier);
-  FLAG_experimental_liftoff_extern_ref = true;
 
   const byte type_index = tester.DefineArray(wasm::kWasmI32, true);
   ValueType kRefTypes[] = {ref(type_index)};
@@ -690,7 +682,6 @@ WASM_COMPILED_EXEC_TEST(WasmBasicArray) {
 
 WASM_COMPILED_EXEC_TEST(WasmPackedArrayU) {
   WasmGCTester tester(execution_tier);
-  FLAG_experimental_liftoff_extern_ref = true;
   const byte array_index = tester.DefineArray(kWasmI8, true);
   ValueType array_type = optref(array_index);
 
@@ -726,7 +717,6 @@ WASM_COMPILED_EXEC_TEST(WasmPackedArrayU) {
 
 WASM_COMPILED_EXEC_TEST(WasmPackedArrayS) {
   WasmGCTester tester(execution_tier);
-  FLAG_experimental_liftoff_extern_ref = true;
   const byte array_index = tester.DefineArray(kWasmI16, true);
   ValueType array_type = optref(array_index);
 
@@ -762,7 +752,6 @@ WASM_COMPILED_EXEC_TEST(WasmPackedArrayS) {
 
 WASM_COMPILED_EXEC_TEST(NewDefault) {
   WasmGCTester tester(execution_tier);
-  FLAG_experimental_liftoff_extern_ref = true;
   const byte struct_type = tester.DefineStruct(
       {F(wasm::kWasmI32, true), F(wasm::kWasmF64, true), F(optref(0), true)});
   const byte array_type = tester.DefineArray(wasm::kWasmI32, true);
@@ -958,7 +947,6 @@ TEST(NoDepthRtt) {
 
 WASM_COMPILED_EXEC_TEST(ArrayNewMap) {
   WasmGCTester tester(execution_tier);
-  FLAG_experimental_liftoff_extern_ref = true;
 
   const byte type_index = tester.DefineArray(kWasmI32, true);
 
@@ -987,7 +975,6 @@ WASM_COMPILED_EXEC_TEST(ArrayNewMap) {
 
 WASM_COMPILED_EXEC_TEST(FunctionRefs) {
   WasmGCTester tester(execution_tier);
-  FLAG_experimental_liftoff_extern_ref = true;
   const byte func_index =
       tester.DefineFunction(tester.sigs.i_v(), {}, {WASM_I32V(42), kExprEnd});
   const byte sig_index = 0;
@@ -1046,7 +1033,6 @@ WASM_COMPILED_EXEC_TEST(FunctionRefs) {
 
 WASM_COMPILED_EXEC_TEST(CallRef) {
   WasmGCTester tester(execution_tier);
-  FLAG_experimental_liftoff_extern_ref = true;
   byte callee = tester.DefineFunction(
       tester.sigs.i_ii(), {},
       {WASM_I32_ADD(WASM_LOCAL_GET(0), WASM_LOCAL_GET(1)), kExprEnd});
@@ -1066,7 +1052,6 @@ WASM_COMPILED_EXEC_TEST(CallRef) {
 
 WASM_COMPILED_EXEC_TEST(RefTestCastNull) {
   WasmGCTester tester(execution_tier);
-  FLAG_experimental_liftoff_extern_ref = true;
   byte type_index = tester.DefineStruct({F(wasm::kWasmI32, true)});
 
   const byte kRefTestNull = tester.DefineFunction(
@@ -1215,7 +1200,6 @@ WASM_COMPILED_EXEC_TEST(AbstractTypeChecks) {
 
 WASM_COMPILED_EXEC_TEST(BasicI31) {
   WasmGCTester tester(execution_tier);
-  FLAG_experimental_liftoff_extern_ref = true;
   const byte kSigned = tester.DefineFunction(
       tester.sigs.i_i(), {},
       {WASM_I31_GET_S(WASM_I31_NEW(WASM_LOCAL_GET(0))), kExprEnd});
@@ -1237,7 +1221,6 @@ WASM_COMPILED_EXEC_TEST(BasicI31) {
 // be modified (made to run longer) to measure performance of casts.
 WASM_COMPILED_EXEC_TEST(CastsBenchmark) {
   WasmGCTester tester(execution_tier);
-  FLAG_experimental_liftoff_extern_ref = true;
   const byte SuperType = tester.DefineStruct({F(wasm::kWasmI32, true)});
   const byte SubType =
       tester.DefineStruct({F(wasm::kWasmI32, true), F(wasm::kWasmI32, true)});
@@ -1337,7 +1320,6 @@ WASM_COMPILED_EXEC_TEST(CastsBenchmark) {
 
 WASM_COMPILED_EXEC_TEST(GlobalInitReferencingGlobal) {
   WasmGCTester tester(execution_tier);
-  FLAG_experimental_liftoff_extern_ref = true;
   const byte from = tester.AddGlobal(kWasmI32, false, WasmInitExpr(42));
   const byte to =
       tester.AddGlobal(kWasmI32, false, WasmInitExpr::GlobalGet(from));
@@ -1352,7 +1334,6 @@ WASM_COMPILED_EXEC_TEST(GlobalInitReferencingGlobal) {
 
 WASM_COMPILED_EXEC_TEST(IndirectNullSetManually) {
   WasmGCTester tester(execution_tier);
-  FLAG_experimental_liftoff_extern_ref = true;
   byte sig_index = tester.DefineSignature(tester.sigs.i_i());
   tester.DefineTable(ValueType::Ref(sig_index, kNullable), 1, 1);
   byte func_index = tester.DefineFunction(
@@ -1366,8 +1347,8 @@ WASM_COMPILED_EXEC_TEST(IndirectNullSetManually) {
   tester.CheckHasThrown(func_index, 42);
 }
 
-TEST(JsAccess) {
-  WasmGCTester tester;
+WASM_COMPILED_EXEC_TEST(JsAccess) {
+  WasmGCTester tester(execution_tier);
   const byte type_index = tester.DefineStruct({F(wasm::kWasmI32, true)});
   ValueType kRefType = ref(type_index);
   ValueType kSupertypeToI[] = {kWasmI32, kWasmDataRef};

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

@@ -3311,8 +3311,6 @@ TEST_F(WasmModuleVerifyTest, Memory64DataSegment) {
 #undef NOP_BODY
 #undef SIG_ENTRY_i_i
 #undef UNKNOWN_SECTION
-#undef COUNT_ARGS
-#undef CHECK_LEB1
 #undef ADD_COUNT
 #undef SECTION
 #undef TYPE_SECTION

test/unittests/wasm/subtyping-unittest.cc

@@ -66,100 +66,104 @@ TEST_F(WasmSubtypingTest, Subtyping) {
     // Value types are unrelated, except if they are equal.
     for (ValueType subtype : numeric_types) {
       for (ValueType supertype : numeric_types) {
-        CHECK_EQ(IsSubtypeOf(subtype, supertype, module1, module),
-                 subtype == supertype);
+        EXPECT_EQ(IsSubtypeOf(subtype, supertype, module1, module),
+                  subtype == supertype);
       }
     }
 
     // Value types are unrelated with reference types.
     for (ValueType value_type : numeric_types) {
       for (ValueType ref_type : ref_types) {
-        CHECK(!IsSubtypeOf(value_type, ref_type, module1, module));
-        CHECK(!IsSubtypeOf(ref_type, value_type, module1, module));
+        EXPECT_TRUE(!IsSubtypeOf(value_type, ref_type, module1, module));
+        EXPECT_TRUE(!IsSubtypeOf(ref_type, value_type, module1, module));
       }
     }
 
     for (ValueType ref_type : ref_types) {
       // Concrete reference types, i31ref and dataref are subtypes of eqref,
       // externref/funcref/anyref are not.
-      CHECK_EQ(IsSubtypeOf(ref_type, kWasmEqRef, module1, module),
-               ref_type != kWasmFuncRef && ref_type != kWasmExternRef &&
-                   ref_type != kWasmAnyRef);
+      EXPECT_EQ(IsSubtypeOf(ref_type, kWasmEqRef, module1, module),
+                ref_type != kWasmFuncRef && ref_type != kWasmExternRef &&
+                    ref_type != kWasmAnyRef);
       // Non-nullable struct/array types are subtypes of dataref.
-      CHECK_EQ(
+      EXPECT_EQ(
           IsSubtypeOf(ref_type, kWasmDataRef, module1, module),
           ref_type == kWasmDataRef ||
               (ref_type.kind() == ValueType::kRef && ref_type.has_index()));
       // Each reference type is a subtype of itself.
-      CHECK(IsSubtypeOf(ref_type, ref_type, module1, module));
+      EXPECT_TRUE(IsSubtypeOf(ref_type, ref_type, module1, module));
       // Each reference type is a subtype of anyref.
-      CHECK(IsSubtypeOf(ref_type, kWasmAnyRef, module1, module));
+      EXPECT_TRUE(IsSubtypeOf(ref_type, kWasmAnyRef, module1, module));
       // Only anyref is a subtype of anyref.
-      CHECK_EQ(IsSubtypeOf(kWasmAnyRef, ref_type, module1, module),
-               ref_type == kWasmAnyRef);
+      EXPECT_EQ(IsSubtypeOf(kWasmAnyRef, ref_type, module1, module),
+                ref_type == kWasmAnyRef);
     }
 
     // The rest of ref. types are unrelated.
     for (ValueType type_1 : {kWasmExternRef, kWasmFuncRef, kWasmI31Ref}) {
       for (ValueType type_2 : {kWasmExternRef, kWasmFuncRef, kWasmI31Ref}) {
-        CHECK_EQ(IsSubtypeOf(type_1, type_2, module1, module),
-                 type_1 == type_2);
+        EXPECT_EQ(IsSubtypeOf(type_1, type_2, module1, module),
+                  type_1 == type_2);
       }
     }
 
     // Unrelated refs are unrelated.
-    CHECK(!IsSubtypeOf(ref(0), ref(2), module1, module));
-    CHECK(!IsSubtypeOf(optRef(3), optRef(1), module1, module));
+    EXPECT_TRUE(!IsSubtypeOf(ref(0), ref(2), module1, module));
+    EXPECT_TRUE(!IsSubtypeOf(optRef(3), optRef(1), module1, module));
     // ref is a subtype of optref for the same struct/array.
-    CHECK(IsSubtypeOf(ref(0), optRef(0), module1, module));
-    CHECK(IsSubtypeOf(ref(2), optRef(2), module1, module));
+    EXPECT_TRUE(IsSubtypeOf(ref(0), optRef(0), module1, module));
+    EXPECT_TRUE(IsSubtypeOf(ref(2), optRef(2), module1, module));
     // optref is not a subtype of ref for the same struct/array.
-    CHECK(!IsSubtypeOf(optRef(0), ref(0), module1, module));
-    CHECK(!IsSubtypeOf(optRef(2), ref(2), module1, module));
+    EXPECT_TRUE(!IsSubtypeOf(optRef(0), ref(0), module1, module));
+    EXPECT_TRUE(!IsSubtypeOf(optRef(2), ref(2), module1, module));
     // ref is a subtype of optref if the same is true for the underlying
     // structs/arrays.
-    CHECK(IsSubtypeOf(ref(3), optRef(2), module1, module));
+    EXPECT_TRUE(IsSubtypeOf(ref(3), optRef(2), module1, module));
     // Prefix subtyping for structs.
-    CHECK(IsSubtypeOf(optRef(4), optRef(0), module1, module));
+    EXPECT_TRUE(IsSubtypeOf(optRef(4), optRef(0), module1, module));
     // Mutable fields are invariant.
-    CHECK(!IsSubtypeOf(ref(0), ref(5), module1, module));
+    EXPECT_TRUE(!IsSubtypeOf(ref(0), ref(5), module1, module));
     // Immutable fields are covariant.
-    CHECK(IsSubtypeOf(ref(1), ref(0), module1, module));
+    EXPECT_TRUE(IsSubtypeOf(ref(1), ref(0), module1, module));
     // Prefix subtyping + immutable field covariance for structs.
-    CHECK(IsSubtypeOf(optRef(4), optRef(1), module1, module));
+    EXPECT_TRUE(IsSubtypeOf(optRef(4), optRef(1), module1, module));
     // No subtyping between mutable/immutable fields.
-    CHECK(!IsSubtypeOf(ref(7), ref(6), module1, module));
-    CHECK(!IsSubtypeOf(ref(6), ref(7), module1, module));
+    EXPECT_TRUE(!IsSubtypeOf(ref(7), ref(6), module1, module));
+    EXPECT_TRUE(!IsSubtypeOf(ref(6), ref(7), module1, module));
     // Recursive types.
-    CHECK(IsSubtypeOf(ref(9), ref(8), module1, module));
+    EXPECT_TRUE(IsSubtypeOf(ref(9), ref(8), module1, module));
 
     // Identical rtts are subtypes of each other.
-    CHECK(IsSubtypeOf(ValueType::Rtt(5, 3), ValueType::Rtt(5, 3), module1,
-                      module2));
-    CHECK(IsSubtypeOf(ValueType::Rtt(5), ValueType::Rtt(5), module1, module2));
+    EXPECT_TRUE(IsSubtypeOf(ValueType::Rtt(5, 3), ValueType::Rtt(5, 3), module1,
+                            module2));
+    EXPECT_TRUE(
+        IsSubtypeOf(ValueType::Rtt(5), ValueType::Rtt(5), module1, module2));
     // Rtts of unrelated types are unrelated.
-    CHECK(!IsSubtypeOf(ValueType::Rtt(1, 1), ValueType::Rtt(2, 1), module1,
-                       module2));
-    CHECK(!IsSubtypeOf(ValueType::Rtt(1), ValueType::Rtt(2), module1, module2));
-    CHECK(!IsSubtypeOf(ValueType::Rtt(1, 0), ValueType::Rtt(2), module1,
-                       module2));
+    EXPECT_TRUE(!IsSubtypeOf(ValueType::Rtt(1, 1), ValueType::Rtt(2, 1),
+                             module1, module2));
+    EXPECT_TRUE(
+        !IsSubtypeOf(ValueType::Rtt(1), ValueType::Rtt(2), module1, module2));
+    EXPECT_TRUE(!IsSubtypeOf(ValueType::Rtt(1, 0), ValueType::Rtt(2), module1,
+                             module2));
     // Rtts of different depth are unrelated.
-    CHECK(!IsSubtypeOf(ValueType::Rtt(5, 1), ValueType::Rtt(5, 3), module1,
-                       module2));
-    CHECK(!IsSubtypeOf(ValueType::Rtt(5, 8), ValueType::Rtt(5, 3), module1,
-                       module2));
+    EXPECT_TRUE(!IsSubtypeOf(ValueType::Rtt(5, 1), ValueType::Rtt(5, 3),
+                             module1, module2));
+    EXPECT_TRUE(!IsSubtypeOf(ValueType::Rtt(5, 8), ValueType::Rtt(5, 3),
+                             module1, module2));
     // Rtts of identical types are subtype-related.
-    CHECK(IsSubtypeOf(ValueType::Rtt(8, 1), ValueType::Rtt(9, 1), module1,
-                      module));
-    CHECK(IsSubtypeOf(ValueType::Rtt(8), ValueType::Rtt(9), module1, module));
+    EXPECT_TRUE(IsSubtypeOf(ValueType::Rtt(8, 1), ValueType::Rtt(9, 1), module1,
+                            module));
+    EXPECT_TRUE(
+        IsSubtypeOf(ValueType::Rtt(8), ValueType::Rtt(9), module1, module));
     // Rtts of subtypes are not related.
-    CHECK(!IsSubtypeOf(ValueType::Rtt(1, 1), ValueType::Rtt(0, 1), module1,
-                       module));
-    CHECK(!IsSubtypeOf(ValueType::Rtt(1), ValueType::Rtt(0), module1, module));
+    EXPECT_TRUE(!IsSubtypeOf(ValueType::Rtt(1, 1), ValueType::Rtt(0, 1),
+                             module1, module));
+    EXPECT_TRUE(
+        !IsSubtypeOf(ValueType::Rtt(1), ValueType::Rtt(0), module1, module));
     // rtt(t, d) <: rtt(t)
     for (uint8_t depth : {0, 1, 5}) {
-      CHECK(IsSubtypeOf(ValueType::Rtt(1, depth), ValueType::Rtt(1), module1,
-                        module));
+      EXPECT_TRUE(IsSubtypeOf(ValueType::Rtt(1, depth), ValueType::Rtt(1),
+                              module1, module));
     }
   }
 }

test/unittests/wasm/trap-handler-posix-unittest.cc

@@ -53,7 +53,8 @@ TEST_F(SignalHandlerFallbackTest, DoTest) {
   const int save_sigs = 1;
   if (!sigsetjmp(continuation_, save_sigs)) {
     constexpr bool use_default_signal_handler = true;
-    CHECK(v8::V8::EnableWebAssemblyTrapHandler(use_default_signal_handler));
+    EXPECT_TRUE(
+        v8::V8::EnableWebAssemblyTrapHandler(use_default_signal_handler));
     CrashOnPurpose();
     FAIL();
   } else {

test/unittests/wasm/trap-handler-win-unittest.cc

@@ -52,7 +52,7 @@ class ExceptionHandlerFallbackTest : public ::testing::Test {
   void TearDown() override {
     // be a good citizen and remove the exception handler.
     ULONG result = RemoveVectoredExceptionHandler(registered_handler_);
-    CHECK(result);
+    EXPECT_TRUE(result);
   }
 
  private:
@@ -61,9 +61,9 @@ class ExceptionHandlerFallbackTest : public ::testing::Test {
     v8::PageAllocator* page_allocator = i::GetPlatformPageAllocator();
     // Make the allocated memory accessible so that from now on memory accesses
     // do not cause an exception anymore.
-    CHECK(i::SetPermissions(page_allocator, g_start_address,
-                            page_allocator->AllocatePageSize(),
-                            v8::PageAllocator::kReadWrite));
+    EXPECT_TRUE(i::SetPermissions(page_allocator, g_start_address,
+                                  page_allocator->AllocatePageSize(),
+                                  v8::PageAllocator::kReadWrite));
     // The memory access should work now, we can continue execution.
     return EXCEPTION_CONTINUE_EXECUTION;
   }
@@ -74,7 +74,7 @@ class ExceptionHandlerFallbackTest : public ::testing::Test {
 
 TEST_F(ExceptionHandlerFallbackTest, DoTest) {
   constexpr bool use_default_handler = true;
-  CHECK(v8::V8::EnableWebAssemblyTrapHandler(use_default_handler));
+  EXPECT_TRUE(v8::V8::EnableWebAssemblyTrapHandler(use_default_handler));
   // In the original test setup the test memory is protected against any kind of
   // access. Therefore the access here causes an access violation exception,
   // which should be caught by the exception handler we install above. In the
@@ -83,8 +83,8 @@ TEST_F(ExceptionHandlerFallbackTest, DoTest) {
   // memory access again. This time we expect the memory access to work.
   constexpr int test_value = 42;
   WriteToTestMemory(test_value);
-  CHECK_EQ(test_value, ReadFromTestMemory());
-  CHECK(g_handler_got_executed);
+  EXPECT_EQ(test_value, ReadFromTestMemory());
+  EXPECT_TRUE(g_handler_got_executed);
   v8::internal::trap_handler::RemoveTrapHandler();
 }
 

test/unittests/wasm/trap-handler-x64-unittest.cc

@@ -85,7 +85,7 @@ class TrapHandlerTest : public TestWithIsolate,
     backing_store_ = BackingStore::AllocateWasmMemory(i_isolate(), 1, 1,
                                                       SharedFlag::kNotShared);
     CHECK(backing_store_);
-    CHECK(backing_store_->has_guard_regions());
+    EXPECT_TRUE(backing_store_->has_guard_regions());
     // The allocated backing store ends with a guard page.
     crash_address_ = reinterpret_cast<Address>(backing_store_->buffer_start()) +
                      backing_store_->byte_length() + 32;
@@ -104,11 +104,11 @@ class TrapHandlerTest : public TestWithIsolate,
     sigemptyset(&action.sa_mask);
     action.sa_flags = SA_SIGINFO;
     // SIGSEGV happens for wasm oob memory accesses on Linux.
-    CHECK_EQ(0, sigaction(SIGSEGV, &action, &g_old_segv_action));
+    EXPECT_EQ(0, sigaction(SIGSEGV, &action, &g_old_segv_action));
     // SIGBUS happens for wasm oob memory accesses on macOS.
-    CHECK_EQ(0, sigaction(SIGBUS, &action, &g_old_bus_action));
+    EXPECT_EQ(0, sigaction(SIGBUS, &action, &g_old_bus_action));
     // SIGFPE to simulate crashes which are not handled by the trap handler.
-    CHECK_EQ(0, sigaction(SIGFPE, &action, &g_old_fpe_action));
+    EXPECT_EQ(0, sigaction(SIGFPE, &action, &g_old_fpe_action));
 #elif V8_OS_WIN
     g_registered_handler =
         AddVectoredExceptionHandler(/*first=*/0, TestHandler);
@@ -117,7 +117,7 @@ class TrapHandlerTest : public TestWithIsolate,
 
   void TearDown() override {
     // We should always have left wasm code.
-    CHECK(!GetThreadInWasmFlag());
+    EXPECT_TRUE(!GetThreadInWasmFlag());
     buffer_.reset();
     recovery_buffer_.reset();
     backing_store_.reset();
@@ -128,9 +128,9 @@ class TrapHandlerTest : public TestWithIsolate,
 #if V8_OS_LINUX || V8_OS_MACOSX || V8_OS_FREEBSD
       // The test handler cleans up the signal handler setup in the test. If the
       // test handler was not called, we have to do the cleanup ourselves.
-      CHECK_EQ(0, sigaction(SIGSEGV, &g_old_segv_action, nullptr));
-      CHECK_EQ(0, sigaction(SIGFPE, &g_old_fpe_action, nullptr));
-      CHECK_EQ(0, sigaction(SIGBUS, &g_old_bus_action, nullptr));
+      EXPECT_EQ(0, sigaction(SIGSEGV, &g_old_segv_action, nullptr));
+      EXPECT_EQ(0, sigaction(SIGFPE, &g_old_fpe_action, nullptr));
+      EXPECT_EQ(0, sigaction(SIGBUS, &g_old_bus_action, nullptr));
 #elif V8_OS_WIN
       RemoveVectoredExceptionHandler(g_registered_handler);
       g_registered_handler = nullptr;
@@ -232,21 +232,21 @@ class TrapHandlerTest : public TestWithIsolate,
     GeneratedCode<void>::FromAddress(
         i_isolate(), reinterpret_cast<Address>(buffer_->start()))
         .Call();
-    CHECK(!g_test_handler_executed);
+    EXPECT_FALSE(g_test_handler_executed);
   }
 
   // Execute the code in buffer. We expect a crash which we recover from in the
   // test handler.
   void ExecuteExpectCrash(TestingAssemblerBuffer* buffer,
                           bool check_wasm_flag = true) {
-    CHECK(!g_test_handler_executed);
+    EXPECT_FALSE(g_test_handler_executed);
     buffer->MakeExecutable();
     GeneratedCode<void>::FromAddress(i_isolate(),
                                      reinterpret_cast<Address>(buffer->start()))
         .Call();
-    CHECK(g_test_handler_executed);
+    EXPECT_TRUE(g_test_handler_executed);
     g_test_handler_executed = false;
-    if (check_wasm_flag) CHECK(!GetThreadInWasmFlag());
+    if (check_wasm_flag) EXPECT_FALSE(GetThreadInWasmFlag());
   }
 
   bool test_handler_executed() { return g_test_handler_executed; }
@@ -457,12 +457,12 @@ TEST_P(TrapHandlerTest, TestCrashInOtherThread) {
                                     desc.instr_size, 1, &protected_instruction);
 
   CodeRunner runner(this, buffer_.get());
-  CHECK(!GetThreadInWasmFlag());
+  EXPECT_FALSE(GetThreadInWasmFlag());
   // Set the thread-in-wasm flag manually in this thread.
   *trap_handler::GetThreadInWasmThreadLocalAddress() = 1;
-  CHECK(runner.Start());
+  EXPECT_TRUE(runner.Start());
   runner.Join();
-  CHECK(GetThreadInWasmFlag());
+  EXPECT_TRUE(GetThreadInWasmFlag());
   // Reset the thread-in-wasm flag.
   *trap_handler::GetThreadInWasmThreadLocalAddress() = 0;
 }

test/unittests/wasm/wasm-code-manager-unittest.cc

@@ -28,16 +28,16 @@ void DisjointAllocationPoolTest::CheckPool(
     const DisjointAllocationPool& mem,
     std::initializer_list<base::AddressRegion> expected_regions) {
   const auto& regions = mem.regions();
-  CHECK_EQ(regions.size(), expected_regions.size());
+  EXPECT_EQ(regions.size(), expected_regions.size());
   auto iter = expected_regions.begin();
   for (auto it = regions.begin(), e = regions.end(); it != e; ++it, ++iter) {
-    CHECK_EQ(*it, *iter);
+    EXPECT_EQ(*it, *iter);
   }
 }
 
 void DisjointAllocationPoolTest::CheckRange(base::AddressRegion region1,
                                             base::AddressRegion region2) {
-  CHECK_EQ(region1, region2);
+  EXPECT_EQ(region1, region2);
 }
 
 DisjointAllocationPool DisjointAllocationPoolTest::Make(
@@ -51,7 +51,7 @@ DisjointAllocationPool DisjointAllocationPoolTest::Make(
 
 TEST_F(DisjointAllocationPoolTest, ConstructEmpty) {
   DisjointAllocationPool a;
-  CHECK(a.IsEmpty());
+  EXPECT_TRUE(a.IsEmpty());
   CheckPool(a, {});
   a.Merge({1, 4});
   CheckPool(a, {{1, 4}});
@@ -59,7 +59,7 @@ TEST_F(DisjointAllocationPoolTest, ConstructEmpty) {
 
 TEST_F(DisjointAllocationPoolTest, ConstructWithRange) {
   DisjointAllocationPool a({1, 4});
-  CHECK(!a.IsEmpty());
+  EXPECT_FALSE(a.IsEmpty());
   CheckPool(a, {{1, 4}});
 }
 
@@ -70,16 +70,16 @@ TEST_F(DisjointAllocationPoolTest, SimpleExtract) {
   CheckRange(b, {1, 2});
   a.Merge(b);
   CheckPool(a, {{1, 4}});
-  CHECK_EQ(a.regions().size(), 1);
-  CHECK_EQ(a.regions().begin()->begin(), 1);
-  CHECK_EQ(a.regions().begin()->end(), 5);
+  EXPECT_EQ(a.regions().size(), uint32_t{1});
+  EXPECT_EQ(a.regions().begin()->begin(), uint32_t{1});
+  EXPECT_EQ(a.regions().begin()->end(), uint32_t{5});
 }
 
 TEST_F(DisjointAllocationPoolTest, ExtractAll) {
   DisjointAllocationPool a({1, 4});
   base::AddressRegion b = a.Allocate(4);
   CheckRange(b, {1, 4});
-  CHECK(a.IsEmpty());
+  EXPECT_TRUE(a.IsEmpty());
   a.Merge(b);
   CheckPool(a, {{1, 4}});
 }
@@ -88,14 +88,14 @@ TEST_F(DisjointAllocationPoolTest, FailToExtract) {
   DisjointAllocationPool a = Make({{1, 4}});
   base::AddressRegion b = a.Allocate(5);
   CheckPool(a, {{1, 4}});
-  CHECK(b.is_empty());
+  EXPECT_TRUE(b.is_empty());
 }
 
 TEST_F(DisjointAllocationPoolTest, FailToExtractExact) {
   DisjointAllocationPool a = Make({{1, 4}, {10, 4}});
   base::AddressRegion b = a.Allocate(5);
   CheckPool(a, {{1, 4}, {10, 4}});
-  CHECK(b.is_empty());
+  EXPECT_TRUE(b.is_empty());
 }
 
 TEST_F(DisjointAllocationPoolTest, ExtractExact) {

test/unittests/wasm/wasm-compiler-unittest.cc

@@ -22,7 +22,7 @@ TEST_F(WasmCallDescriptorTest, TestExternRefIsGrouped) {
 
   for (size_t i = 0; i < kMaxCount; i += 2) {
     params[i] = kWasmExternRef;
-    CHECK_LT(i + 1, kMaxCount);
+    EXPECT_TRUE(i + 1 < kMaxCount);
     params[i + 1] = kWasmI32;
   }
 
@@ -32,7 +32,7 @@ TEST_F(WasmCallDescriptorTest, TestExternRefIsGrouped) {
         compiler::GetWasmCallDescriptor(zone(), &sig);
 
     // The WasmInstance is the implicit first parameter.
-    CHECK_EQ(count + 1, desc->ParameterCount());
+    EXPECT_EQ(count + 1, desc->ParameterCount());
 
     bool has_untagged_stack_param = false;
     bool has_tagged_register_param = false;
@@ -45,7 +45,7 @@ TEST_F(WasmCallDescriptorTest, TestExternRefIsGrouped) {
         if (location.IsRegister()) {
           has_tagged_register_param = true;
         } else {
-          CHECK(location.IsCallerFrameSlot());
+          EXPECT_TRUE(location.IsCallerFrameSlot());
           max_tagged_stack_location =
               std::max(max_tagged_stack_location, location.AsCallerFrameSlot());
         }
@@ -55,14 +55,14 @@ TEST_F(WasmCallDescriptorTest, TestExternRefIsGrouped) {
           min_untagged_stack_location = std::min(min_untagged_stack_location,
                                                  location.AsCallerFrameSlot());
         } else {
-          CHECK(location.IsRegister());
+          EXPECT_TRUE(location.IsRegister());
         }
       }
     }
     // There should never be a tagged parameter in a register and an untagged
     // parameter on the stack at the same time.
-    CHECK_EQ(false, has_tagged_register_param && has_untagged_stack_param);
-    CHECK_LT(max_tagged_stack_location, min_untagged_stack_location);
+    EXPECT_EQ(false, has_tagged_register_param && has_untagged_stack_param);
+    EXPECT_TRUE(max_tagged_stack_location < min_untagged_stack_location);
   }
 }