Re-enable various MSVC warnings.

base/allocator/allocator_unittest.cc

 // Copyright 2014 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.
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <algorithm>   // for min()
 
 #include "base/atomicops.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // Number of bits in a size_t.
 static const int kSizeBits = 8 * sizeof(size_t);
 // The maximum size of a size_t.
 static const size_t kMaxSize = ~static_cast<size_t>(0);
 // Maximum positive size of a size_t if it were signed.
 static const size_t kMaxSignedSize = ((size_t(1) << (kSizeBits-1)) - 1);
-// An allocation size which is not too big to be reasonable.
-static const size_t kNotTooBig = 100000;
-// An allocation size which is just too big.
-static const size_t kTooBig = ~static_cast<size_t>(0);
 
 namespace {
 
 using std::min;
 
 // Fill a buffer of the specified size with a predetermined pattern
 static void Fill(unsigned char* buffer, int n) {
   for (int i = 0; i < n; i++) {
     buffer[i] = (i & 0xff);
   }
@@ skipping 248 matching lines @@
   } else {
     EXPECT_NE(reinterpret_cast<void*>(NULL), p) <<
         "calloc(n, s) should succeed";
     for (int i = 0; i < n*s; i++) {
       EXPECT_EQ('\0', p[i]);
     }
     free(p);
   }
 }
 
-
-// A global test counter for number of times the NewHandler is called.
-static int news_handled = 0;
-static void TestNewHandler() {
-  ++news_handled;
-  throw std::bad_alloc();
-}
-
-// Because we compile without exceptions, we expect these will not throw.
-static void TestOneNewWithoutExceptions(void* (*func)(size_t),
-                                        bool should_throw) {
-  // success test
-  try {
-    void* ptr = (*func)(kNotTooBig);
-    EXPECT_NE(reinterpret_cast<void*>(NULL), ptr) <<
-        "allocation should not have failed.";
-  } catch(...) {
-    EXPECT_EQ(0, 1) << "allocation threw unexpected exception.";
-  }
-
-  // failure test
-  try {
-    void* rv = (*func)(kTooBig);

[brettw, 2014/07/25 20:19:20]

I kind of like this test for the behavior that a "too big" allocation returns
null rather than crashes or whatever. I don't see another test that covers this.

It's also nice to check that people didn't accidentally enable exceptions. Is
there a way to check for this case, like a define or something?

[Peter Kasting, 2014/07/25 20:54:42]

I think there are two options.  One would be to #pragma disable the relevant
warning here.  The other would be to do something like:

#if defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS
#error
#endif

The second way is briefer, but only works under MSVC.

I'm a little reluctant to do either one, because (a) it seems extremely unlikely
that we'll bring up Chrome on another platform and enable exceptions, since our
code is littered with exception-unsafe idioms, and (b) if someone did this
intentionally for some reason -- especially for projects that may depend on
base/ without being full-blown Chromium -- they really wouldn't _want_ this test
to prevent them from doing that.

However, maybe these don't outweigh the benefit of the test.  Changed.

-    EXPECT_EQ(NULL, rv);
-    EXPECT_FALSE(should_throw) << "allocation should have thrown.";
-  } catch(...) {
-    EXPECT_TRUE(should_throw) << "allocation threw unexpected exception.";
-  }
-}
-
-static void TestNothrowNew(void* (*func)(size_t)) {
-  news_handled = 0;
-
-  // test without new_handler:
-  std::new_handler saved_handler = std::set_new_handler(0);
-  TestOneNewWithoutExceptions(func, false);
-
-  // test with new_handler:
-  std::set_new_handler(TestNewHandler);
-  TestOneNewWithoutExceptions(func, true);
-  EXPECT_EQ(news_handled, 1) << "nothrow new_handler was not called.";
-  std::set_new_handler(saved_handler);
-}
-
 }  // namespace
 
 //-----------------------------------------------------------------------------
 
 TEST(Atomics, AtomicIncrementWord) {
   TestAtomicIncrement<AtomicWord>();
 }
 
 TEST(Atomics, AtomicIncrement32) {
   TestAtomicIncrement<Atomic32>();
@@ skipping 32 matching lines @@
 
   TestCalloc(kMaxSize, 2, false);
   TestCalloc(2, kMaxSize, false);
   TestCalloc(kMaxSize, kMaxSize, false);
 
   TestCalloc(kMaxSignedSize, 3, false);
   TestCalloc(3, kMaxSignedSize, false);
   TestCalloc(kMaxSignedSize, kMaxSignedSize, false);
 }
 
-TEST(Allocators, New) {
-  TestNothrowNew(&::operator new);
-  TestNothrowNew(&::operator new[]);
-}
-
 // This makes sure that reallocing a small number of bytes in either
 // direction doesn't cause us to allocate new memory.
 TEST(Allocators, Realloc1) {
   int start_sizes[] = { 100, 1000, 10000, 100000 };
   int deltas[] = { 1, -2, 4, -8, 16, -32, 64, -128 };
 
   for (int s = 0; s < sizeof(start_sizes)/sizeof(*start_sizes); ++s) {
     void* p = malloc(start_sizes[s]);
     ASSERT_TRUE(p);
     // The larger the start-size, the larger the non-reallocing delta.
@@ skipping 110 matching lines @@
   }
 }
 
 #endif
 
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }