Fix gtest warnings when running the process_util_unittest.

base/process_util_unittest.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #define _CRT_SECURE_NO_WARNINGS
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/eintr_wrapper.h"
@@ skipping 537 matching lines @@
 
 // TODO(vandebo) make this work on Windows too.
 #if !defined(OS_WIN)
 
 #if defined(USE_TCMALLOC)
 extern "C" {
 int tc_set_new_mode(int mode);
 }
 #endif  // defined(USE_TCMALLOC)
 
-class OutOfMemoryTest : public testing::Test {
+class OutOfMemoryDeathTest : public testing::Test {
  public:
-  OutOfMemoryTest()
+  OutOfMemoryDeathTest()
       : value_(NULL),
         // Make test size as large as possible minus a few pages so
         // that alignment or other rounding doesn't make it wrap.
         test_size_(std::numeric_limits<std::size_t>::max() - 12 * 1024),
         signed_test_size_(std::numeric_limits<ssize_t>::max()) {
   }
 
   virtual void SetUp() {
-    // Must call EnableTerminationOnOutOfMemory() because that is called from
-    // chrome's main function and therefore hasn't been called yet.
-    base::EnableTerminationOnOutOfMemory();
 #if defined(USE_TCMALLOC)
     tc_set_new_mode(1);
   }
 
   virtual void TearDown() {
     tc_set_new_mode(0);
 #endif  // defined(USE_TCMALLOC)
   }
 
+  void SetUpInDeathAssert() {
+    // Must call EnableTerminationOnOutOfMemory() because that is called from
+    // chrome's main function and therefore hasn't been called yet.
+    // Since this call may result in another thread being created and death
+    // tests shouldn't be started in a multithread environment, this call
+    // should be done inside of the ASSERT_DEATH.
+    base::EnableTerminationOnOutOfMemory();
+  }
+
   void* value_;
   size_t test_size_;
   ssize_t signed_test_size_;
 };
 
-TEST_F(OutOfMemoryTest, New) {
-  ASSERT_DEATH(value_ = operator new(test_size_), "");
+TEST_F(OutOfMemoryDeathTest, New) {
+  ASSERT_DEATH({
+      SetUpInDeathAssert();

[vandebo (ex-Chrome), 2010/08/23 21:52:14]

Is there a reason to put these inside the macro call?

+      value_ = operator new(test_size_);
+    }, "");
 }
 
-TEST_F(OutOfMemoryTest, NewArray) {
-  ASSERT_DEATH(value_ = new char[test_size_], "");
+TEST_F(OutOfMemoryDeathTest, NewArray) {
+  ASSERT_DEATH({
+      SetUpInDeathAssert();
+      value_ = new char[test_size_];
+    }, "");
 }
 
-TEST_F(OutOfMemoryTest, Malloc) {
-  ASSERT_DEATH(value_ = malloc(test_size_), "");
+TEST_F(OutOfMemoryDeathTest, Malloc) {
+  ASSERT_DEATH({
+      SetUpInDeathAssert();
+      value_ = malloc(test_size_);
+    }, "");
 }
 
-TEST_F(OutOfMemoryTest, Realloc) {
-  ASSERT_DEATH(value_ = realloc(NULL, test_size_), "");
+TEST_F(OutOfMemoryDeathTest, Realloc) {
+  ASSERT_DEATH({
+      SetUpInDeathAssert();
+      value_ = realloc(NULL, test_size_);
+    }, "");
 }
 
-TEST_F(OutOfMemoryTest, Calloc) {
-  ASSERT_DEATH(value_ = calloc(1024, test_size_ / 1024L), "");
+TEST_F(OutOfMemoryDeathTest, Calloc) {
+  ASSERT_DEATH({
+      SetUpInDeathAssert();
+      value_ = calloc(1024, test_size_ / 1024L);
+    }, "");
 }
 
-TEST_F(OutOfMemoryTest, Valloc) {
-  ASSERT_DEATH(value_ = valloc(test_size_), "");
+TEST_F(OutOfMemoryDeathTest, Valloc) {
+  ASSERT_DEATH({
+      SetUpInDeathAssert();
+      value_ = valloc(test_size_);
+    }, "");
 }
 
 #if defined(OS_LINUX)
-TEST_F(OutOfMemoryTest, Pvalloc) {
-  ASSERT_DEATH(value_ = pvalloc(test_size_), "");
+TEST_F(OutOfMemoryDeathTest, Pvalloc) {
+  ASSERT_DEATH({
+      SetUpInDeathAssert();
+      value_ = pvalloc(test_size_);
+    }, "");
 }
 
-TEST_F(OutOfMemoryTest, Memalign) {
-  ASSERT_DEATH(value_ = memalign(4, test_size_), "");
+TEST_F(OutOfMemoryDeathTest, Memalign) {
+  ASSERT_DEATH({
+      SetUpInDeathAssert();
+      value_ = memalign(4, test_size_);
+    }, "");
 }
 
-TEST_F(OutOfMemoryTest, ViaSharedLibraries) {
+TEST_F(OutOfMemoryDeathTest, ViaSharedLibraries) {
   // g_try_malloc is documented to return NULL on failure. (g_malloc is the
   // 'safe' default that crashes if allocation fails). However, since we have
   // hopefully overridden malloc, even g_try_malloc should fail. This tests
   // that the run-time symbol resolution is overriding malloc for shared
   // libraries as well as for our code.
-  ASSERT_DEATH(value_ = g_try_malloc(test_size_), "");
+  ASSERT_DEATH({
+      SetUpInDeathAssert();
+      value_ = g_try_malloc(test_size_);
+    }, "");
 }
 #endif  // OS_LINUX
 
 #if defined(OS_POSIX)
-TEST_F(OutOfMemoryTest, Posix_memalign) {
+TEST_F(OutOfMemoryDeathTest, Posix_memalign) {
   typedef int (*memalign_t)(void **, size_t, size_t);
 #if defined(OS_MACOSX)
   // posix_memalign only exists on >= 10.6. Use dlsym to grab it at runtime
   // because it may not be present in the SDK used for compilation.
   memalign_t memalign =
       reinterpret_cast<memalign_t>(dlsym(RTLD_DEFAULT, "posix_memalign"));
 #else
   memalign_t memalign = posix_memalign;
 #endif  // OS_*
   if (memalign) {
     // Grab the return value of posix_memalign to silence a compiler warning
     // about unused return values. We don't actually care about the return
     // value, since we're asserting death.
-    ASSERT_DEATH(EXPECT_EQ(ENOMEM, memalign(&value_, 8, test_size_)), "");
+    ASSERT_DEATH({
+        SetUpInDeathAssert();
+        EXPECT_EQ(ENOMEM, memalign(&value_, 8, test_size_));
+      }, "");
   }
 }
 #endif  // OS_POSIX
 
 #if defined(OS_MACOSX)
 
 // Purgeable zone tests (if it exists)
 
-TEST_F(OutOfMemoryTest, MallocPurgeable) {
+TEST_F(OutOfMemoryDeathTest, MallocPurgeable) {
   malloc_zone_t* zone = base::GetPurgeableZone();
   if (zone)
-    ASSERT_DEATH(value_ = malloc_zone_malloc(zone, test_size_), "");
+    ASSERT_DEATH({
+        SetUpInDeathAssert();
+        value_ = malloc_zone_malloc(zone, test_size_);
+      }, "");
 }
 
-TEST_F(OutOfMemoryTest, ReallocPurgeable) {
+TEST_F(OutOfMemoryDeathTest, ReallocPurgeable) {
   malloc_zone_t* zone = base::GetPurgeableZone();
   if (zone)
-    ASSERT_DEATH(value_ = malloc_zone_realloc(zone, NULL, test_size_), "");
+    ASSERT_DEATH({
+        SetUpInDeathAssert();
+        value_ = malloc_zone_realloc(zone, NULL, test_size_);
+      }, "");
 }
 
-TEST_F(OutOfMemoryTest, CallocPurgeable) {
+TEST_F(OutOfMemoryDeathTest, CallocPurgeable) {
   malloc_zone_t* zone = base::GetPurgeableZone();
   if (zone)
-    ASSERT_DEATH(value_ = malloc_zone_calloc(zone, 1024, test_size_ / 1024L),
-                 "");
+    ASSERT_DEATH({
+        SetUpInDeathAssert();
+        value_ = malloc_zone_calloc(zone, 1024, test_size_ / 1024L);
+      }, "");
 }
 
-TEST_F(OutOfMemoryTest, VallocPurgeable) {
+TEST_F(OutOfMemoryDeathTest, VallocPurgeable) {
   malloc_zone_t* zone = base::GetPurgeableZone();
   if (zone)
-    ASSERT_DEATH(value_ = malloc_zone_valloc(zone, test_size_), "");
+    ASSERT_DEATH({
+        SetUpInDeathAssert();
+        value_ = malloc_zone_valloc(zone, test_size_);
+      }, "");
 }
 
-TEST_F(OutOfMemoryTest, PosixMemalignPurgeable) {
+TEST_F(OutOfMemoryDeathTest, PosixMemalignPurgeable) {
   malloc_zone_t* zone = base::GetPurgeableZone();
 
   typedef void* (*zone_memalign_t)(malloc_zone_t*, size_t, size_t);
   // malloc_zone_memalign only exists on >= 10.6. Use dlsym to grab it at
   // runtime because it may not be present in the SDK used for compilation.
   zone_memalign_t zone_memalign =
       reinterpret_cast<zone_memalign_t>(
         dlsym(RTLD_DEFAULT, "malloc_zone_memalign"));
 
   if (zone && zone_memalign) {
-    ASSERT_DEATH(value_ = zone_memalign(zone, 8, test_size_), "");
+    ASSERT_DEATH({
+        SetUpInDeathAssert();
+        value_ = zone_memalign(zone, 8, test_size_);
+      }, "");
   }
 }
 
 // Since these allocation functions take a signed size, it's possible that
 // calling them just once won't be enough to exhaust memory. In the 32-bit
 // environment, it's likely that these allocation attempts will fail because
 // not enough contiguous address space is availble. In the 64-bit environment,
 // it's likely that they'll fail because they would require a preposterous
 // amount of (virtual) memory.
 
-TEST_F(OutOfMemoryTest, CFAllocatorSystemDefault) {
-  ASSERT_DEATH(while ((value_ =
-      base::AllocateViaCFAllocatorSystemDefault(signed_test_size_))) {}, "");
+TEST_F(OutOfMemoryDeathTest, CFAllocatorSystemDefault) {
+  ASSERT_DEATH({
+      SetUpInDeathAssert();
+      while ((value_ =
+              base::AllocateViaCFAllocatorSystemDefault(signed_test_size_))) {}
+    }, "");
 }
 
-TEST_F(OutOfMemoryTest, CFAllocatorMalloc) {
-  ASSERT_DEATH(while ((value_ =
-      base::AllocateViaCFAllocatorMalloc(signed_test_size_))) {}, "");
+TEST_F(OutOfMemoryDeathTest, CFAllocatorMalloc) {
+  ASSERT_DEATH({
+      SetUpInDeathAssert();
+      while ((value_ =
+              base::AllocateViaCFAllocatorMalloc(signed_test_size_))) {}
+    }, "");
 }
 
-TEST_F(OutOfMemoryTest, CFAllocatorMallocZone) {
-  ASSERT_DEATH(while ((value_ =
-      base::AllocateViaCFAllocatorMallocZone(signed_test_size_))) {}, "");
+TEST_F(OutOfMemoryDeathTest, CFAllocatorMallocZone) {
+  ASSERT_DEATH({
+      SetUpInDeathAssert();
+      while ((value_ =
+              base::AllocateViaCFAllocatorMallocZone(signed_test_size_))) {}
+    }, "");
 }
 
 #if !defined(ARCH_CPU_64_BITS)
 
 // See process_util_unittest_mac.mm for an explanation of why this test isn't
 // run in the 64-bit environment.
 
-TEST_F(OutOfMemoryTest, PsychoticallyBigObjCObject) {
-  ASSERT_DEATH(while ((value_ =
-      base::AllocatePsychoticallyBigObjCObject())) {}, "");
+TEST_F(OutOfMemoryDeathTest, PsychoticallyBigObjCObject) {
+  ASSERT_DEATH({
+      SetUpInDeathAssert();
+      while ((value_ = base::AllocatePsychoticallyBigObjCObject())) {}
+    }, "");
 }
 
 #endif  // !ARCH_CPU_64_BITS
 #endif  // OS_MACOSX
 
 #endif  // !defined(OS_WIN)