Merged third_party/tcmalloc/vendor/src(google-perftools r87) into...

third_party/tcmalloc/chromium/src/tests/debugallocation_test.cc

 // Copyright (c) 2007, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 84 matching lines @@
 
   // Allocate with new[].
   {
     int* x = new int[1];
     IF_DEBUG_EXPECT_DEATH(free(x), "mismatch.*being dealloc.*free");
     IF_DEBUG_EXPECT_DEATH(delete x, "mismatch.*being dealloc.*delete");
     delete [] x;
   }
 }
 
+TEST(DebugAllocationTest, DoubleFree) {
+  int* pint = new int;
+  delete pint;
+  IF_DEBUG_EXPECT_DEATH(delete pint, "has been already deallocated");
+}
+
+TEST(DebugAllocationTest, StompBefore) {
+  int* pint = new int;
+#ifndef NDEBUG   // don't stomp memory if we're not in a position to detect it
+  pint[-1] = 5;
+  IF_DEBUG_EXPECT_DEATH(delete pint, "a word before object");
+#endif
+}
+
+TEST(DebugAllocationTest, StompAfter) {
+  int* pint = new int;
+#ifndef NDEBUG   // don't stomp memory if we're not in a position to detect it
+  pint[1] = 5;
+  IF_DEBUG_EXPECT_DEATH(delete pint, "a word after object");
+#endif
+}
+
 TEST(DebugAllocationTest, FreeQueueTest) {
   // Verify that the allocator doesn't return blocks that were recently freed.
   int* x = new int;
   int* old_x = x;
   delete x;
   x = new int;
   #if 1
     // This check should not be read as a universal guarantee of behavior.  If
     // other threads are executing, it would be theoretically possible for this
     // check to fail despite the efforts of debugallocation.cc to the contrary.
@@ skipping 83 matching lines @@
   }
 #endif
   void* a = malloc(1000);
   EXPECT_GE(MallocExtension::instance()->GetAllocatedSize(a), 1000);
   // This is just a sanity check.  If we allocated too much, alloc is broken
   EXPECT_LE(MallocExtension::instance()->GetAllocatedSize(a), 5000);
   EXPECT_GE(MallocExtension::instance()->GetEstimatedAllocatedSize(1000), 1000);
   free(a);
 }
 
+TEST(DebugAllocationTest, HugeAlloc) {
+  const size_t kTooBig = ~static_cast<size_t>(0);
+  void* a = NULL;
+  char* b = NULL;
+
+#ifndef NDEBUG
+
+  a = malloc(kTooBig);
+  EXPECT_EQ(NULL, a);
+  b = NULL;
+  IF_DEBUG_EXPECT_DEATH(b = new char[kTooBig],
+                        "Unable to allocate.*new\\[\\] failed\\.");
+  EXPECT_EQ(NULL, b);
+
+  // kAlsoTooBig is small enough not to get caught by debugallocation's check,
+  // but will still fall through to tcmalloc's check.
+  const size_t kAlsoTooBig = kTooBig - 1024;
+
+  a = malloc(kAlsoTooBig);
+  EXPECT_EQ(NULL, a);
+  IF_DEBUG_EXPECT_DEATH(b = new char[kAlsoTooBig], "Unable to allocate.*new failed");
+  EXPECT_EQ(NULL, b);
+#endif
+}
+
 int main(int argc, char** argv) {
   // If you run without args, we run the non-death parts of the test.
   // Otherwise, argv[1] should be a number saying which death-test
   // to run.  We will output a regexp we expect the death-message
   // to include, and then run the given death test (which hopefully
   // will produce that error message).  If argv[1] > the number of
   // death tests, we will run only the non-death parts.  One way to
   // tell when you are done with all tests is when no 'expected
   // regexp' message is printed for a given argv[1].
   if (argc < 2) {
     test_to_run = -1;   // will never match
   } else {
     test_to_run = atoi(argv[1]);
   }
   return RUN_ALL_TESTS();
 }