From 5f4fdb378ce25fc2d1f3498b4cfed54b5d8ff699 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tobias=20Nie=C3=9Fen?= Date: Mon, 26 Sep 2022 10:00:38 +0000 Subject: [PATCH] test: use CHECK instead of EXPECT where necessary GetPageSize() and OverrunGuardedBuffer currently use non-fatal EXPECT_* macros because GoogleTest does not allow the fatal variants ASSERT_* in non-void returning functions (i.e., in this file, nowhere outside of the TEST itself). The EXPECT_* macros continue execution upon failure, but we really don't want that (and static analysis apparently does not like it either). Since we cannot use GoogleTest's ASSERT_* here, use our own CHECK_* instead of EXPECT_* outside of the TEST. Hopefully, this will finally pacify static analysis. Refs: https://github.com/nodejs/node/pull/44666 PR-URL: https://github.com/nodejs/node/pull/44795 Reviewed-By: Darshan Sen Reviewed-By: James M Snell Reviewed-By: Erick Wendel Reviewed-By: Michael Dawson --- test/cctest/test_crypto_clienthello.cc | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/test/cctest/test_crypto_clienthello.cc b/test/cctest/test_crypto_clienthello.cc index 60a8e294c890a9..870857cf906109 100644 --- a/test/cctest/test_crypto_clienthello.cc +++ b/test/cctest/test_crypto_clienthello.cc @@ -32,7 +32,7 @@ #if defined(USE_MPROTECT) size_t GetPageSize() { int page_size = sysconf(_SC_PAGE_SIZE); - EXPECT_GE(page_size, 1); + CHECK_GE(page_size, 1); return page_size; } #elif defined(USE_VIRTUALPROTECT) @@ -49,32 +49,32 @@ class OverrunGuardedBuffer { OverrunGuardedBuffer() { #if defined(USE_MPROTECT) || defined(USE_VIRTUALPROTECT) size_t page = GetPageSize(); - EXPECT_GE(page, N); + CHECK_GE(page, N); #endif #ifdef USE_MPROTECT // Place the packet right before a guard page, which, when accessed, causes // a segmentation fault. alloc_base = static_cast(aligned_alloc(page, 2 * page)); - EXPECT_NE(alloc_base, nullptr); + CHECK_NOT_NULL(alloc_base); uint8_t* second_page = alloc_base + page; - EXPECT_EQ(mprotect(second_page, page, PROT_NONE), 0); + CHECK_EQ(mprotect(second_page, page, PROT_NONE), 0); data_base = second_page - N; #elif defined(USE_VIRTUALPROTECT) // On Windows, it works almost the same way. alloc_base = static_cast( VirtualAlloc(nullptr, 2 * page, MEM_COMMIT, PAGE_READWRITE)); - EXPECT_NE(alloc_base, nullptr); + CHECK_NOT_NULL(alloc_base); uint8_t* second_page = alloc_base + page; DWORD old_prot; - EXPECT_NE(VirtualProtect(second_page, page, PAGE_NOACCESS, &old_prot), 0); - EXPECT_EQ(old_prot, PAGE_READWRITE); + CHECK_NE(VirtualProtect(second_page, page, PAGE_NOACCESS, &old_prot), 0); + CHECK_EQ(old_prot, PAGE_READWRITE); data_base = second_page - N; #else // Place the packet in a regular allocated buffer. The bug causes undefined // behavior, which might crash the process, and when it does not, address // sanitizers and valgrind will catch it. alloc_base = static_cast(malloc(N)); - EXPECT_NE(alloc_base, nullptr); + CHECK_NOT_NULL(alloc_base); data_base = alloc_base; #endif } @@ -92,7 +92,7 @@ class OverrunGuardedBuffer { #ifdef USE_MPROTECT // Revert page protection such that the memory can be free()'d. uint8_t* second_page = alloc_base + page; - EXPECT_EQ(mprotect(second_page, page, PROT_READ | PROT_WRITE), 0); + CHECK_EQ(mprotect(second_page, page, PROT_READ | PROT_WRITE), 0); #endif free(alloc_base); #endif