Clang: enable -Wbool-conversions and -Wunused-variables on Linux.

base/allocator/allocator_unittests.cc

 // Copyright (c) 2009 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 "base/logging.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 295 matching lines @@
     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);
     EXPECT_EQ(NULL, rv);
-    EXPECT_EQ(false, should_throw) << "allocation should have thrown.";
+    EXPECT_FALSE(should_throw) << "allocation should have thrown.";
   } catch(...) {
-    EXPECT_EQ(true, should_throw) << "allocation threw unexpected exception.";
+    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);
 
@@ skipping 23 matching lines @@
 TEST(Atomics, AtomicOps32) {
   TestAtomicIncrement<Atomic32>();
 }
 
 TEST(Allocators, Malloc) {
   // Try allocating data with a bunch of alignments and sizes
   for (int size = 1; size < 1048576; size *= 2) {
     unsigned char* ptr = reinterpret_cast<unsigned char*>(malloc(size));
     CheckAlignment(ptr, 2);  // Should be 2 byte aligned
     Fill(ptr, size);
-    EXPECT_EQ(true, Valid(ptr, size));
+    EXPECT_TRUE(Valid(ptr, size));
     free(ptr);
   }
 }
 
 TEST(Allocators, Calloc) {
   TestCalloc(0, 0, true);
   TestCalloc(0, 1, true);
   TestCalloc(1, 1, true);
   TestCalloc(1<<10, 0, true);
   TestCalloc(1<<20, 0, true);
@@ skipping 40 matching lines @@
   }
 }
 
 TEST(Allocators, Realloc2) {
   for (int src_size = 0; src_size >= 0; src_size = NextSize(src_size)) {
     for (int dst_size = 0; dst_size >= 0; dst_size = NextSize(dst_size)) {
       unsigned char* src = reinterpret_cast<unsigned char*>(malloc(src_size));
       Fill(src, src_size);
       unsigned char* dst =
           reinterpret_cast<unsigned char*>(realloc(src, dst_size));
-      EXPECT_EQ(true, Valid(dst, min(src_size, dst_size)));
+      EXPECT_TRUE(Valid(dst, min(src_size, dst_size)));
       Fill(dst, dst_size);
-      EXPECT_EQ(true, Valid(dst, dst_size));
+      EXPECT_TRUE(Valid(dst, dst_size));
       if (dst != NULL) free(dst);
     }
   }
 
   // Now make sure realloc works correctly even when we overflow the
   // packed cache, so some entries are evicted from the cache.
   // The cache has 2^12 entries, keyed by page number.
   const int kNumEntries = 1 << 14;
   int** p = reinterpret_cast<int**>(malloc(sizeof(*p) * kNumEntries));
   int sum = 0;
@@ skipping 25 matching lines @@
   }
 }
 
 #ifdef WIN32
 // Test recalloc
 TEST(Allocators, Recalloc) {
   for (int src_size = 0; src_size >= 0; src_size = NextSize(src_size)) {
     for (int dst_size = 0; dst_size >= 0; dst_size = NextSize(dst_size)) {
       unsigned char* src =
           reinterpret_cast<unsigned char*>(_recalloc(NULL, 1, src_size));
-      EXPECT_EQ(true, IsZeroed(src, src_size));
+      EXPECT_TRUE(IsZeroed(src, src_size));
       Fill(src, src_size);
       unsigned char* dst =
           reinterpret_cast<unsigned char*>(_recalloc(src, 1, dst_size));
-      EXPECT_EQ(true, Valid(dst, min(src_size, dst_size)));
+      EXPECT_TRUE(Valid(dst, min(src_size, dst_size)));
       Fill(dst, dst_size);
-      EXPECT_EQ(true, Valid(dst, dst_size));
+      EXPECT_TRUE(Valid(dst, dst_size));
       if (dst != NULL)
         free(dst);
     }
   }
 }
 #endif
 
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }