Use the partition allocator and run the test in debug too.

Source/wtf/PartitionAllocTest.cpp

 /*
  * Copyright (C) 2013 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 28 matching lines @@
 #include <string.h>
 
 #if OS(UNIX)
 #include <sys/mman.h>
 
 #ifndef MAP_ANONYMOUS
 #define MAP_ANONYMOUS MAP_ANON
 #endif
 #endif // OS(UNIX)
 
-#if defined(NDEBUG) && !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
+#if !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
 
 namespace {
 
 static PartitionRoot root;
 
 static const int kTestAllocSize = sizeof(void*);
 
 static void RandomNumberSource(unsigned char* buf, size_t len)
 {
     memset(buf, '\0', len);
 }
 
 static void TestSetup()
 {
     WTF::setRandomSource(RandomNumberSource);
     partitionAllocInit(&root);
 }
 
 static void TestShutdown()
 {
-    partitionAllocShutdown(&root);
+    // We expect no leaks in the general case. We have a test for leak
+    // detection.
+    EXPECT_TRUE(partitionAllocShutdown(&root));
 }
 
 static WTF::PartitionPageHeader* GetFullPage(size_t size)
 {
     size_t bucketIdx = size >> WTF::kBucketShift;
     WTF::PartitionBucket* bucket = &root.buckets[bucketIdx];
     size_t numSlots = (WTF::kPartitionPageSize - sizeof(WTF::PartitionPageHeader)) / size;
     void* first = 0;
     void* last = 0;
     size_t i;
@@ skipping 45 matching lines @@
     // Check that the offset appears to include a guard page.
     EXPECT_EQ(WTF::kPartitionPageSize + sizeof(WTF::PartitionPageHeader), reinterpret_cast<size_t>(ptr) & WTF::kSuperPageOffsetMask);
 
     partitionFree(ptr);
     // Expect that a just-freed page doesn't get tossed to the freelist.
     EXPECT_EQ(0, bucket->freePages);
 
     TestShutdown();
 }
 
+// Check that we can detect a memory leak.
+TEST(WTF_PartitionAlloc, SimpleLeak)
+{
+    TestSetup();
+    void* leakedPtr = partitionAlloc(&root, kTestAllocSize);
+    EXPECT_FALSE(partitionAllocShutdown(&root));
+}
+
 // Test multiple allocations, and freelist handling.
 TEST(WTF_PartitionAlloc, MultiAlloc)
 {
     TestSetup();
 
     char* ptr1 = reinterpret_cast<char*>(partitionAlloc(&root, kTestAllocSize));
     char* ptr2 = reinterpret_cast<char*>(partitionAlloc(&root, kTestAllocSize));
     EXPECT_TRUE(ptr1);
     EXPECT_TRUE(ptr2);
     ptrdiff_t diff = ptr2 - ptr1;
@@ skipping 229 matching lines @@
     munmap(map1, WTF::kSystemPageSize);
     munmap(map2, WTF::kSystemPageSize);
 
     TestShutdown();
 }
 
 #endif // OS(UNIX)
 
 } // namespace
 
-#endif // defined(NDEBUG) && !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
+#endif // !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)