Reland "Initial switch to Chromium-style CHECK_* and DCHECK_* macros.".

test/cctest/test-heap-profiler.cc

 // Copyright 2011 the V8 project authors. 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
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 173 matching lines @@
       "var b2_1 = new B2(a2), b2_2 = new B2(a2);\n"
       "var c2 = new C2(a2);");
   const v8::HeapSnapshot* snapshot_env2 =
       heap_profiler->TakeHeapSnapshot(v8_str("env2"));
   CHECK(ValidateSnapshot(snapshot_env2));
   const v8::HeapGraphNode* global_env2 = GetGlobalObject(snapshot_env2);
 
   // Verify, that JS global object of env2 has '..2' properties.
   const v8::HeapGraphNode* a2_node =
       GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "a2");
-  CHECK_NE(NULL, a2_node);
-  CHECK_NE(
-      NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "b2_1"));
-  CHECK_NE(
-      NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "b2_2"));
-  CHECK_NE(NULL, GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "c2"));
+  CHECK(a2_node);
+  CHECK(GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "b2_1"));
+  CHECK(GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "b2_2"));
+  CHECK(GetProperty(global_env2, v8::HeapGraphEdge::kProperty, "c2"));
 
   NamedEntriesDetector det;
   det.CheckAllReachables(const_cast<i::HeapEntry*>(
       reinterpret_cast<const i::HeapEntry*>(global_env2)));
   CHECK(det.has_A2);
   CHECK(det.has_B2);
   CHECK(det.has_C2);
 }
 
 
 TEST(HeapSnapshotObjectSizes) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
   //   -a-> X1 --a
   // x -b-> X2 <-|
   CompileRun(
       "function X(a, b) { this.a = a; this.b = b; }\n"
       "x = new X(new X(), new X());\n"
       "dummy = new X();\n"
       "(function() { x.a.a = x.b; })();");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("sizes"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* x =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "x");
-  CHECK_NE(NULL, x);
+  CHECK(x);
   const v8::HeapGraphNode* x1 =
       GetProperty(x, v8::HeapGraphEdge::kProperty, "a");
-  CHECK_NE(NULL, x1);
+  CHECK(x1);
   const v8::HeapGraphNode* x2 =
       GetProperty(x, v8::HeapGraphEdge::kProperty, "b");
-  CHECK_NE(NULL, x2);
+  CHECK(x2);
 
   // Test sizes.
   CHECK_NE(0, static_cast<int>(x->GetShallowSize()));
   CHECK_NE(0, static_cast<int>(x1->GetShallowSize()));
   CHECK_NE(0, static_cast<int>(x2->GetShallowSize()));
 }
 
 
 TEST(BoundFunctionInSnapshot) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   CompileRun(
       "function myFunction(a, b) { this.a = a; this.b = b; }\n"
       "function AAAAA() {}\n"
       "boundFunction = myFunction.bind(new AAAAA(), 20, new Number(12)); \n");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("sizes"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* f =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "boundFunction");
   CHECK(f);
-  CHECK_EQ(v8::String::NewFromUtf8(env->GetIsolate(), "native_bind"),
-           f->GetName());
+  CHECK(v8::String::NewFromUtf8(env->GetIsolate(), "native_bind")
+            ->Equals(f->GetName()));
   const v8::HeapGraphNode* bindings =
       GetProperty(f, v8::HeapGraphEdge::kInternal, "bindings");
-  CHECK_NE(NULL, bindings);
+  CHECK(bindings);
   CHECK_EQ(v8::HeapGraphNode::kArray, bindings->GetType());
   CHECK_EQ(3, bindings->GetChildrenCount());
 
   const v8::HeapGraphNode* bound_this = GetProperty(
       f, v8::HeapGraphEdge::kShortcut, "bound_this");
   CHECK(bound_this);
   CHECK_EQ(v8::HeapGraphNode::kObject, bound_this->GetType());
 
   const v8::HeapGraphNode* bound_function = GetProperty(
       f, v8::HeapGraphEdge::kShortcut, "bound_function");
@@ skipping 18 matching lines @@
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("children"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
   for (int i = 0, count = global->GetChildrenCount(); i < count; ++i) {
     const v8::HeapGraphEdge* prop = global->GetChild(i);
     CHECK_EQ(global, prop->GetFromNode());
   }
   const v8::HeapGraphNode* a =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "a");
-  CHECK_NE(NULL, a);
+  CHECK(a);
   for (int i = 0, count = a->GetChildrenCount(); i < count; ++i) {
     const v8::HeapGraphEdge* prop = a->GetChild(i);
     CHECK_EQ(a, prop->GetFromNode());
   }
 }
 
 
 TEST(HeapSnapshotCodeObjects) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
   CompileRun(
       "function lazy(x) { return x - 1; }\n"
       "function compiled(x) { return x + 1; }\n"
       "var anonymous = (function() { return function() { return 0; } })();\n"
       "compiled(1)");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("code"));
   CHECK(ValidateSnapshot(snapshot));
 
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* compiled =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "compiled");
-  CHECK_NE(NULL, compiled);
+  CHECK(compiled);
   CHECK_EQ(v8::HeapGraphNode::kClosure, compiled->GetType());
   const v8::HeapGraphNode* lazy =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "lazy");
-  CHECK_NE(NULL, lazy);
+  CHECK(lazy);
   CHECK_EQ(v8::HeapGraphNode::kClosure, lazy->GetType());
   const v8::HeapGraphNode* anonymous =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "anonymous");
-  CHECK_NE(NULL, anonymous);
+  CHECK(anonymous);
   CHECK_EQ(v8::HeapGraphNode::kClosure, anonymous->GetType());
   v8::String::Utf8Value anonymous_name(anonymous->GetName());
-  CHECK_EQ("", *anonymous_name);
+  CHECK_EQ(0, strcmp("", *anonymous_name));
 
   // Find references to code.
   const v8::HeapGraphNode* compiled_code =
       GetProperty(compiled, v8::HeapGraphEdge::kInternal, "shared");
-  CHECK_NE(NULL, compiled_code);
+  CHECK(compiled_code);
   const v8::HeapGraphNode* lazy_code =
       GetProperty(lazy, v8::HeapGraphEdge::kInternal, "shared");
-  CHECK_NE(NULL, lazy_code);
+  CHECK(lazy_code);
 
   // Check that there's no strong next_code_link. There might be a weak one
   // but might be not, so we can't check that fact.
   const v8::HeapGraphNode* code =
       GetProperty(compiled_code, v8::HeapGraphEdge::kInternal, "code");
-  CHECK_NE(NULL, code);
+  CHECK(code);
   const v8::HeapGraphNode* next_code_link =
       GetProperty(code, v8::HeapGraphEdge::kInternal, "code");
-  CHECK_EQ(NULL, next_code_link);
+  CHECK(!next_code_link);
 
   // Verify that non-compiled code doesn't contain references to "x"
   // literal, while compiled code does. The scope info is stored in FixedArray
   // objects attached to the SharedFunctionInfo.
   bool compiled_references_x = false, lazy_references_x = false;
   for (int i = 0, count = compiled_code->GetChildrenCount(); i < count; ++i) {
     const v8::HeapGraphEdge* prop = compiled_code->GetChild(i);
     const v8::HeapGraphNode* node = prop->GetToNode();
     if (node->GetType() == v8::HeapGraphNode::kArray) {
       if (HasString(node, "x")) {
@@ skipping 21 matching lines @@
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   CompileRun(
       "a = 1;    // a is Smi\n"
       "b = 2.5;  // b is HeapNumber");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("numbers"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
-  CHECK_EQ(NULL, GetProperty(global, v8::HeapGraphEdge::kProperty, "a"));
+  CHECK(!GetProperty(global, v8::HeapGraphEdge::kProperty, "a"));
   const v8::HeapGraphNode* b =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "b");
-  CHECK_NE(NULL, b);
+  CHECK(b);
   CHECK_EQ(v8::HeapGraphNode::kHeapNumber, b->GetType());
 }
 
 
 TEST(HeapSnapshotSlicedString) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   CompileRun(
       "parent_string = \"123456789.123456789.123456789.123456789.123456789."
       "123456789.123456789.123456789.123456789.123456789."
       "123456789.123456789.123456789.123456789.123456789."
       "123456789.123456789.123456789.123456789.123456789.\";"
       "child_string = parent_string.slice(100);");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("strings"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* parent_string =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "parent_string");
-  CHECK_NE(NULL, parent_string);
+  CHECK(parent_string);
   const v8::HeapGraphNode* child_string =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "child_string");
-  CHECK_NE(NULL, child_string);
+  CHECK(child_string);
   CHECK_EQ(v8::HeapGraphNode::kSlicedString, child_string->GetType());
   const v8::HeapGraphNode* parent =
       GetProperty(child_string, v8::HeapGraphEdge::kInternal, "parent");
   CHECK_EQ(parent_string, parent);
   heap_profiler->DeleteAllHeapSnapshots();
 }
 
 
 TEST(HeapSnapshotConsString) {
   v8::Isolate* isolate = CcTest::isolate();
@@ skipping 15 matching lines @@
   global->SetInternalField(0, v8::ToApiHandle<v8::String>(cons_string));
 
   v8::HeapProfiler* heap_profiler = isolate->GetHeapProfiler();
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("cons_strings"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global_node = GetGlobalObject(snapshot);
 
   const v8::HeapGraphNode* string_node =
       GetProperty(global_node, v8::HeapGraphEdge::kInternal, "0");
-  CHECK_NE(NULL, string_node);
+  CHECK(string_node);
   CHECK_EQ(v8::HeapGraphNode::kConsString, string_node->GetType());
 
   const v8::HeapGraphNode* first_node =
       GetProperty(string_node, v8::HeapGraphEdge::kInternal, "first");
   CHECK_EQ(v8::HeapGraphNode::kString, first_node->GetType());
 
   const v8::HeapGraphNode* second_node =
       GetProperty(string_node, v8::HeapGraphEdge::kInternal, "second");
   CHECK_EQ(v8::HeapGraphNode::kString, second_node->GetType());
 
   heap_profiler->DeleteAllHeapSnapshots();
 }
 
 
 TEST(HeapSnapshotSymbol) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
   CompileRun("a = Symbol('mySymbol');\n");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("Symbol"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* a =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "a");
-  CHECK_NE(NULL, a);
+  CHECK(a);
   CHECK_EQ(a->GetType(), v8::HeapGraphNode::kSymbol);
-  CHECK_EQ(v8_str("symbol"), a->GetName());
+  CHECK(v8_str("symbol")->Equals(a->GetName()));
   const v8::HeapGraphNode* name =
       GetProperty(a, v8::HeapGraphEdge::kInternal, "name");
-  CHECK_NE(NULL, name);
-  CHECK_EQ(v8_str("mySymbol"), name->GetName());
+  CHECK(name);
+  CHECK(v8_str("mySymbol")->Equals(name->GetName()));
 }
 
 
 TEST(HeapSnapshotWeakCollection) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
   CompileRun(
       "k = {}; v = {}; s = 'str';\n"
       "ws = new WeakSet(); ws.add(k); ws.add(v); ws[s] = s;\n"
       "wm = new WeakMap(); wm.set(k, v); wm[s] = s;\n");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("WeakCollections"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* k =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "k");
-  CHECK_NE(NULL, k);
+  CHECK(k);
   const v8::HeapGraphNode* v =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "v");
-  CHECK_NE(NULL, v);
+  CHECK(v);
   const v8::HeapGraphNode* s =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "s");
-  CHECK_NE(NULL, s);
+  CHECK(s);
 
   const v8::HeapGraphNode* ws =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "ws");
-  CHECK_NE(NULL, ws);
+  CHECK(ws);
   CHECK_EQ(v8::HeapGraphNode::kObject, ws->GetType());
-  CHECK_EQ(v8_str("WeakSet"), ws->GetName());
+  CHECK(v8_str("WeakSet")->Equals(ws->GetName()));
 
   const v8::HeapGraphNode* ws_table =
       GetProperty(ws, v8::HeapGraphEdge::kInternal, "table");
   CHECK_EQ(v8::HeapGraphNode::kArray, ws_table->GetType());
   CHECK_GT(ws_table->GetChildrenCount(), 0);
   int weak_entries = 0;
   for (int i = 0, count = ws_table->GetChildrenCount(); i < count; ++i) {
     const v8::HeapGraphEdge* prop = ws_table->GetChild(i);
     if (prop->GetType() != v8::HeapGraphEdge::kWeak) continue;
     if (k->GetId() == prop->GetToNode()->GetId()) {
       ++weak_entries;
     }
   }
   CHECK_EQ(1, weak_entries);
   const v8::HeapGraphNode* ws_s =
       GetProperty(ws, v8::HeapGraphEdge::kProperty, "str");
-  CHECK_NE(NULL, ws_s);
-  CHECK_EQ(static_cast<int>(s->GetId()), static_cast<int>(ws_s->GetId()));
+  CHECK(ws_s);
+  CHECK_EQ(s->GetId(), ws_s->GetId());
 
   const v8::HeapGraphNode* wm =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "wm");
-  CHECK_NE(NULL, wm);
+  CHECK(wm);
   CHECK_EQ(v8::HeapGraphNode::kObject, wm->GetType());
-  CHECK_EQ(v8_str("WeakMap"), wm->GetName());
+  CHECK(v8_str("WeakMap")->Equals(wm->GetName()));
 
   const v8::HeapGraphNode* wm_table =
       GetProperty(wm, v8::HeapGraphEdge::kInternal, "table");
   CHECK_EQ(v8::HeapGraphNode::kArray, wm_table->GetType());
   CHECK_GT(wm_table->GetChildrenCount(), 0);
   weak_entries = 0;
   for (int i = 0, count = wm_table->GetChildrenCount(); i < count; ++i) {
     const v8::HeapGraphEdge* prop = wm_table->GetChild(i);
     if (prop->GetType() != v8::HeapGraphEdge::kWeak) continue;
     const v8::SnapshotObjectId to_node_id = prop->GetToNode()->GetId();
     if (to_node_id == k->GetId() || to_node_id == v->GetId()) {
       ++weak_entries;
     }
   }
   CHECK_EQ(2, weak_entries);
   const v8::HeapGraphNode* wm_s =
       GetProperty(wm, v8::HeapGraphEdge::kProperty, "str");
-  CHECK_NE(NULL, wm_s);
-  CHECK_EQ(static_cast<int>(s->GetId()), static_cast<int>(wm_s->GetId()));
+  CHECK(wm_s);
+  CHECK_EQ(s->GetId(), wm_s->GetId());
 }
 
 
 TEST(HeapSnapshotCollection) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
   CompileRun(
       "k = {}; v = {}; s = 'str';\n"
       "set = new Set(); set.add(k); set.add(v); set[s] = s;\n"
       "map = new Map(); map.set(k, v); map[s] = s;\n");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("Collections"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* k =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "k");
-  CHECK_NE(NULL, k);
+  CHECK(k);
   const v8::HeapGraphNode* v =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "v");
-  CHECK_NE(NULL, v);
+  CHECK(v);
   const v8::HeapGraphNode* s =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "s");
-  CHECK_NE(NULL, s);
+  CHECK(s);
 
   const v8::HeapGraphNode* set =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "set");
-  CHECK_NE(NULL, set);
+  CHECK(set);
   CHECK_EQ(v8::HeapGraphNode::kObject, set->GetType());
-  CHECK_EQ(v8_str("Set"), set->GetName());
+  CHECK(v8_str("Set")->Equals(set->GetName()));
 
   const v8::HeapGraphNode* set_table =
       GetProperty(set, v8::HeapGraphEdge::kInternal, "table");
   CHECK_EQ(v8::HeapGraphNode::kArray, set_table->GetType());
   CHECK_GT(set_table->GetChildrenCount(), 0);
   int entries = 0;
   for (int i = 0, count = set_table->GetChildrenCount(); i < count; ++i) {
     const v8::HeapGraphEdge* prop = set_table->GetChild(i);
     const v8::SnapshotObjectId to_node_id = prop->GetToNode()->GetId();
     if (to_node_id == k->GetId() || to_node_id == v->GetId()) {
       ++entries;
     }
   }
   CHECK_EQ(2, entries);
   const v8::HeapGraphNode* set_s =
       GetProperty(set, v8::HeapGraphEdge::kProperty, "str");
-  CHECK_NE(NULL, set_s);
-  CHECK_EQ(static_cast<int>(s->GetId()), static_cast<int>(set_s->GetId()));
+  CHECK(set_s);
+  CHECK_EQ(s->GetId(), set_s->GetId());
 
   const v8::HeapGraphNode* map =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "map");
-  CHECK_NE(NULL, map);
+  CHECK(map);
   CHECK_EQ(v8::HeapGraphNode::kObject, map->GetType());
-  CHECK_EQ(v8_str("Map"), map->GetName());
+  CHECK(v8_str("Map")->Equals(map->GetName()));
 
   const v8::HeapGraphNode* map_table =
       GetProperty(map, v8::HeapGraphEdge::kInternal, "table");
   CHECK_EQ(v8::HeapGraphNode::kArray, map_table->GetType());
   CHECK_GT(map_table->GetChildrenCount(), 0);
   entries = 0;
   for (int i = 0, count = map_table->GetChildrenCount(); i < count; ++i) {
     const v8::HeapGraphEdge* prop = map_table->GetChild(i);
     const v8::SnapshotObjectId to_node_id = prop->GetToNode()->GetId();
     if (to_node_id == k->GetId() || to_node_id == v->GetId()) {
       ++entries;
     }
   }
   CHECK_EQ(2, entries);
   const v8::HeapGraphNode* map_s =
       GetProperty(map, v8::HeapGraphEdge::kProperty, "str");
-  CHECK_NE(NULL, map_s);
-  CHECK_EQ(static_cast<int>(s->GetId()), static_cast<int>(map_s->GetId()));
+  CHECK(map_s);
+  CHECK_EQ(s->GetId(), map_s->GetId());
 }
 
 
 TEST(HeapSnapshotInternalReferences) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   v8::Local<v8::ObjectTemplate> global_template =
       v8::ObjectTemplate::New(isolate);
   global_template->SetInternalFieldCount(2);
   LocalContext env(NULL, global_template);
   v8::Handle<v8::Object> global_proxy = env->Global();
   v8::Handle<v8::Object> global = global_proxy->GetPrototype().As<v8::Object>();
   CHECK_EQ(2, global->InternalFieldCount());
   v8::Local<v8::Object> obj = v8::Object::New(isolate);
   global->SetInternalField(0, v8_num(17));
   global->SetInternalField(1, obj);
   v8::HeapProfiler* heap_profiler = isolate->GetHeapProfiler();
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("internals"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global_node = GetGlobalObject(snapshot);
   // The first reference will not present, because it's a Smi.
-  CHECK_EQ(NULL, GetProperty(global_node, v8::HeapGraphEdge::kInternal, "0"));
+  CHECK(!GetProperty(global_node, v8::HeapGraphEdge::kInternal, "0"));
   // The second reference is to an object.
-  CHECK_NE(NULL, GetProperty(global_node, v8::HeapGraphEdge::kInternal, "1"));
+  CHECK(GetProperty(global_node, v8::HeapGraphEdge::kInternal, "1"));
 }
 
 
-// Trying to introduce a check helper for uint32_t causes many
-// overloading ambiguities, so it seems easier just to cast
-// them to a signed type.
-#define CHECK_EQ_SNAPSHOT_OBJECT_ID(a, b) \
-  CHECK_EQ(static_cast<int32_t>(a), static_cast<int32_t>(b))
-#define CHECK_NE_SNAPSHOT_OBJECT_ID(a, b) \
-  CHECK((a) != (b))  // NOLINT
-
 TEST(HeapSnapshotAddressReuse) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
   CompileRun(
       "function A() {}\n"
       "var a = [];\n"
       "for (var i = 0; i < 10000; ++i)\n"
       "  a[i] = new A();\n");
   const v8::HeapSnapshot* snapshot1 =
       heap_profiler->TakeHeapSnapshot(v8_str("snapshot1"));
   CHECK(ValidateSnapshot(snapshot1));
   v8::SnapshotObjectId maxId1 = snapshot1->GetMaxSnapshotJSObjectId();
 
   CompileRun(
       "for (var i = 0; i < 10000; ++i)\n"
       "  a[i] = new A();\n");
   CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
 
   const v8::HeapSnapshot* snapshot2 =
       heap_profiler->TakeHeapSnapshot(v8_str("snapshot2"));
   CHECK(ValidateSnapshot(snapshot2));
   const v8::HeapGraphNode* global2 = GetGlobalObject(snapshot2);
 
   const v8::HeapGraphNode* array_node =
       GetProperty(global2, v8::HeapGraphEdge::kProperty, "a");
-  CHECK_NE(NULL, array_node);
+  CHECK(array_node);
   int wrong_count = 0;
   for (int i = 0, count = array_node->GetChildrenCount(); i < count; ++i) {
     const v8::HeapGraphEdge* prop = array_node->GetChild(i);
     if (prop->GetType() != v8::HeapGraphEdge::kElement)
       continue;
     v8::SnapshotObjectId id = prop->GetToNode()->GetId();
     if (id < maxId1)
       ++wrong_count;
   }
   CHECK_EQ(0, wrong_count);
@@ skipping 22 matching lines @@
       "  a.shift();\n");
 
   CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
 
   const v8::HeapSnapshot* snapshot2 =
       heap_profiler->TakeHeapSnapshot(v8_str("s2"));
   CHECK(ValidateSnapshot(snapshot2));
 
   const v8::HeapGraphNode* global1 = GetGlobalObject(snapshot1);
   const v8::HeapGraphNode* global2 = GetGlobalObject(snapshot2);
-  CHECK_NE_SNAPSHOT_OBJECT_ID(0, global1->GetId());
-  CHECK_EQ_SNAPSHOT_OBJECT_ID(global1->GetId(), global2->GetId());
+  CHECK_NE(0u, global1->GetId());
+  CHECK_EQ(global1->GetId(), global2->GetId());
 
   const v8::HeapGraphNode* a1 =
       GetProperty(global1, v8::HeapGraphEdge::kProperty, "a");
-  CHECK_NE(NULL, a1);
+  CHECK(a1);
   const v8::HeapGraphNode* k1 =
       GetProperty(a1, v8::HeapGraphEdge::kInternal, "elements");
-  CHECK_NE(NULL, k1);
+  CHECK(k1);
   const v8::HeapGraphNode* a2 =
       GetProperty(global2, v8::HeapGraphEdge::kProperty, "a");
-  CHECK_NE(NULL, a2);
+  CHECK(a2);
   const v8::HeapGraphNode* k2 =
       GetProperty(a2, v8::HeapGraphEdge::kInternal, "elements");
-  CHECK_NE(NULL, k2);
+  CHECK(k2);
 
-  CHECK_EQ_SNAPSHOT_OBJECT_ID(a1->GetId(), a2->GetId());
-  CHECK_EQ_SNAPSHOT_OBJECT_ID(k1->GetId(), k2->GetId());
+  CHECK_EQ(a1->GetId(), a2->GetId());
+  CHECK_EQ(k1->GetId(), k2->GetId());
 }
 
 
 TEST(HeapEntryIdsAndGC) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
   CompileRun(
       "function A() {}\n"
       "function B(x) { this.x = x; }\n"
       "var a = new A();\n"
       "var b = new B(a);");
   v8::Local<v8::String> s1_str = v8_str("s1");
   v8::Local<v8::String> s2_str = v8_str("s2");
   const v8::HeapSnapshot* snapshot1 =
       heap_profiler->TakeHeapSnapshot(s1_str);
   CHECK(ValidateSnapshot(snapshot1));
 
   CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
 
   const v8::HeapSnapshot* snapshot2 =
       heap_profiler->TakeHeapSnapshot(s2_str);
   CHECK(ValidateSnapshot(snapshot2));
 
-  CHECK_GT(snapshot1->GetMaxSnapshotJSObjectId(), 7000);
+  CHECK_GT(snapshot1->GetMaxSnapshotJSObjectId(), 7000u);
   CHECK(snapshot1->GetMaxSnapshotJSObjectId() <=
         snapshot2->GetMaxSnapshotJSObjectId());
 
   const v8::HeapGraphNode* global1 = GetGlobalObject(snapshot1);
   const v8::HeapGraphNode* global2 = GetGlobalObject(snapshot2);
-  CHECK_NE_SNAPSHOT_OBJECT_ID(0, global1->GetId());
-  CHECK_EQ_SNAPSHOT_OBJECT_ID(global1->GetId(), global2->GetId());
+  CHECK_NE(0u, global1->GetId());
+  CHECK_EQ(global1->GetId(), global2->GetId());
   const v8::HeapGraphNode* A1 =
       GetProperty(global1, v8::HeapGraphEdge::kProperty, "A");
-  CHECK_NE(NULL, A1);
+  CHECK(A1);
   const v8::HeapGraphNode* A2 =
       GetProperty(global2, v8::HeapGraphEdge::kProperty, "A");
-  CHECK_NE(NULL, A2);
-  CHECK_NE_SNAPSHOT_OBJECT_ID(0, A1->GetId());
-  CHECK_EQ_SNAPSHOT_OBJECT_ID(A1->GetId(), A2->GetId());
+  CHECK(A2);
+  CHECK_NE(0u, A1->GetId());
+  CHECK_EQ(A1->GetId(), A2->GetId());
   const v8::HeapGraphNode* B1 =
       GetProperty(global1, v8::HeapGraphEdge::kProperty, "B");
-  CHECK_NE(NULL, B1);
+  CHECK(B1);
   const v8::HeapGraphNode* B2 =
       GetProperty(global2, v8::HeapGraphEdge::kProperty, "B");
-  CHECK_NE(NULL, B2);
-  CHECK_NE_SNAPSHOT_OBJECT_ID(0, B1->GetId());
-  CHECK_EQ_SNAPSHOT_OBJECT_ID(B1->GetId(), B2->GetId());
+  CHECK(B2);
+  CHECK_NE(0u, B1->GetId());
+  CHECK_EQ(B1->GetId(), B2->GetId());
   const v8::HeapGraphNode* a1 =
       GetProperty(global1, v8::HeapGraphEdge::kProperty, "a");
-  CHECK_NE(NULL, a1);
+  CHECK(a1);
   const v8::HeapGraphNode* a2 =
       GetProperty(global2, v8::HeapGraphEdge::kProperty, "a");
-  CHECK_NE(NULL, a2);
-  CHECK_NE_SNAPSHOT_OBJECT_ID(0, a1->GetId());
-  CHECK_EQ_SNAPSHOT_OBJECT_ID(a1->GetId(), a2->GetId());
+  CHECK(a2);
+  CHECK_NE(0u, a1->GetId());
+  CHECK_EQ(a1->GetId(), a2->GetId());
   const v8::HeapGraphNode* b1 =
       GetProperty(global1, v8::HeapGraphEdge::kProperty, "b");
-  CHECK_NE(NULL, b1);
+  CHECK(b1);
   const v8::HeapGraphNode* b2 =
       GetProperty(global2, v8::HeapGraphEdge::kProperty, "b");
-  CHECK_NE(NULL, b2);
-  CHECK_NE_SNAPSHOT_OBJECT_ID(0, b1->GetId());
-  CHECK_EQ_SNAPSHOT_OBJECT_ID(b1->GetId(), b2->GetId());
+  CHECK(b2);
+  CHECK_NE(0u, b1->GetId());
+  CHECK_EQ(b1->GetId(), b2->GetId());
 }
 
 
 TEST(HeapSnapshotRootPreservedAfterSorting) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("s"));
   CHECK(ValidateSnapshot(snapshot));
@@ skipping 147 matching lines @@
   int string_index = static_cast<int>(
       nodes_array->Get(string_obj_pos + 1)->ToNumber(isolate)->Value());
   CHECK_GT(string_index, 0);
   v8::Local<v8::Object> strings_array =
       parsed_snapshot->Get(v8_str("strings"))->ToObject(isolate);
   v8::Local<v8::String> string =
       strings_array->Get(string_index)->ToString(isolate);
   v8::Local<v8::String> ref_string =
       CompileRun(STRING_LITERAL_FOR_TEST)->ToString(isolate);
 #undef STRING_LITERAL_FOR_TEST
-  CHECK_EQ(*v8::String::Utf8Value(ref_string),
-           *v8::String::Utf8Value(string));
+  CHECK_EQ(0, strcmp(*v8::String::Utf8Value(ref_string),
+                     *v8::String::Utf8Value(string)));
 }
 
 
 TEST(HeapSnapshotJSONSerializationAborting) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("abort"));
   CHECK(ValidateSnapshot(snapshot));
@@ skipping 85 matching lines @@
     CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
   }
 
   v8::SnapshotObjectId initial_id;
   {
     // Single chunk of data expected in update. Initial data.
     TestStatsStream stats_update = GetHeapStatsUpdate(heap_profiler,
                                                       &initial_id);
     CHECK_EQ(1, stats_update.intervals_count());
     CHECK_EQ(1, stats_update.updates_written());
-    CHECK_LT(0, stats_update.entries_size());
+    CHECK_LT(0u, stats_update.entries_size());
     CHECK_EQ(0, stats_update.first_interval_index());
   }
 
   // No data expected in update because nothing has happened.
   v8::SnapshotObjectId same_id;
   CHECK_EQ(0, GetHeapStatsUpdate(heap_profiler, &same_id).updates_written());
-  CHECK_EQ_SNAPSHOT_OBJECT_ID(initial_id, same_id);
+  CHECK_EQ(initial_id, same_id);
 
   {
     v8::SnapshotObjectId additional_string_id;
     v8::HandleScope inner_scope_1(env->GetIsolate());
     v8_str("string1");
     {
       // Single chunk of data with one new entry expected in update.
       TestStatsStream stats_update = GetHeapStatsUpdate(heap_profiler,
                                                         &additional_string_id);
       CHECK_LT(same_id, additional_string_id);
       CHECK_EQ(1, stats_update.intervals_count());
       CHECK_EQ(1, stats_update.updates_written());
-      CHECK_LT(0, stats_update.entries_size());
-      CHECK_EQ(1, stats_update.entries_count());
+      CHECK_LT(0u, stats_update.entries_size());
+      CHECK_EQ(1u, stats_update.entries_count());
       CHECK_EQ(2, stats_update.first_interval_index());
     }
 
     // No data expected in update because nothing happened.
     v8::SnapshotObjectId last_id;
     CHECK_EQ(0, GetHeapStatsUpdate(heap_profiler, &last_id).updates_written());
-    CHECK_EQ_SNAPSHOT_OBJECT_ID(additional_string_id, last_id);
+    CHECK_EQ(additional_string_id, last_id);
 
     {
       v8::HandleScope inner_scope_2(env->GetIsolate());
       v8_str("string2");
 
       uint32_t entries_size;
       {
         v8::HandleScope inner_scope_3(env->GetIsolate());
         v8_str("string3");
         v8_str("string4");
 
         {
           // Single chunk of data with three new entries expected in update.
           TestStatsStream stats_update = GetHeapStatsUpdate(heap_profiler);
           CHECK_EQ(1, stats_update.intervals_count());
           CHECK_EQ(1, stats_update.updates_written());
-          CHECK_LT(0, entries_size = stats_update.entries_size());
-          CHECK_EQ(3, stats_update.entries_count());
+          CHECK_LT(0u, entries_size = stats_update.entries_size());
+          CHECK_EQ(3u, stats_update.entries_count());
           CHECK_EQ(4, stats_update.first_interval_index());
         }
       }
 
       {
         // Single chunk of data with two left entries expected in update.
         TestStatsStream stats_update = GetHeapStatsUpdate(heap_profiler);
         CHECK_EQ(1, stats_update.intervals_count());
         CHECK_EQ(1, stats_update.updates_written());
         CHECK_GT(entries_size, stats_update.entries_size());
-        CHECK_EQ(1, stats_update.entries_count());
+        CHECK_EQ(1u, stats_update.entries_count());
         // Two strings from forth interval were released.
         CHECK_EQ(4, stats_update.first_interval_index());
       }
     }
 
     {
       // Single chunk of data with 0 left entries expected in update.
       TestStatsStream stats_update = GetHeapStatsUpdate(heap_profiler);
       CHECK_EQ(1, stats_update.intervals_count());
       CHECK_EQ(1, stats_update.updates_written());
-      CHECK_EQ(0, stats_update.entries_size());
-      CHECK_EQ(0, stats_update.entries_count());
+      CHECK_EQ(0u, stats_update.entries_size());
+      CHECK_EQ(0u, stats_update.entries_count());
       // The last string from forth interval was released.
       CHECK_EQ(4, stats_update.first_interval_index());
     }
   }
   {
     // Single chunk of data with 0 left entries expected in update.
     TestStatsStream stats_update = GetHeapStatsUpdate(heap_profiler);
     CHECK_EQ(1, stats_update.intervals_count());
     CHECK_EQ(1, stats_update.updates_written());
-    CHECK_EQ(0, stats_update.entries_size());
-    CHECK_EQ(0, stats_update.entries_count());
+    CHECK_EQ(0u, stats_update.entries_size());
+    CHECK_EQ(0u, stats_update.entries_count());
     // The only string from the second interval was released.
     CHECK_EQ(2, stats_update.first_interval_index());
   }
 
   v8::Local<v8::Array> array = v8::Array::New(env->GetIsolate());
-  CHECK_EQ(0, array->Length());
+  CHECK_EQ(0u, array->Length());
   // Force array's buffer allocation.
   array->Set(2, v8_num(7));
 
   uint32_t entries_size;
   {
     // Single chunk of data with 2 entries expected in update.
     TestStatsStream stats_update = GetHeapStatsUpdate(heap_profiler);
     CHECK_EQ(1, stats_update.intervals_count());
     CHECK_EQ(1, stats_update.updates_written());
-    CHECK_LT(0, entries_size = stats_update.entries_size());
+    CHECK_LT(0u, entries_size = stats_update.entries_size());
     // They are the array and its buffer.
-    CHECK_EQ(2, stats_update.entries_count());
+    CHECK_EQ(2u, stats_update.entries_count());
     CHECK_EQ(8, stats_update.first_interval_index());
   }
 
   for (int i = 0; i < 100; ++i)
     array->Set(i, v8_num(i));
 
   {
     // Single chunk of data with 1 entry expected in update.
     TestStatsStream stats_update = GetHeapStatsUpdate(heap_profiler);
     CHECK_EQ(1, stats_update.intervals_count());
     // The first interval was changed because old buffer was collected.
     // The second interval was changed because new buffer was allocated.
     CHECK_EQ(2, stats_update.updates_written());
     CHECK_LT(entries_size, stats_update.entries_size());
-    CHECK_EQ(2, stats_update.entries_count());
+    CHECK_EQ(2u, stats_update.entries_count());
     CHECK_EQ(8, stats_update.first_interval_index());
   }
 
   heap_profiler->StopTrackingHeapObjects();
 }
 
 
 TEST(HeapObjectIds) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
   const int kLength = 10;
   v8::Handle<v8::Object> objects[kLength];
   v8::SnapshotObjectId ids[kLength];
 
   heap_profiler->StartTrackingHeapObjects(false);
 
   for (int i = 0; i < kLength; i++) {
     objects[i] = v8::Object::New(isolate);
   }
   GetHeapStatsUpdate(heap_profiler);
 
   for (int i = 0; i < kLength; i++) {
     v8::SnapshotObjectId id = heap_profiler->GetObjectId(objects[i]);
-    CHECK_NE(v8::HeapProfiler::kUnknownObjectId, static_cast<int>(id));
+    CHECK_NE(v8::HeapProfiler::kUnknownObjectId, id);
     ids[i] = id;
   }
 
   heap_profiler->StopTrackingHeapObjects();
   CcTest::heap()->CollectAllAvailableGarbage();
 
   for (int i = 0; i < kLength; i++) {
     v8::SnapshotObjectId id = heap_profiler->GetObjectId(objects[i]);
-    CHECK_EQ(static_cast<int>(ids[i]), static_cast<int>(id));
+    CHECK_EQ(ids[i], id);
     v8::Handle<v8::Value> obj = heap_profiler->FindObjectById(ids[i]);
-    CHECK_EQ(objects[i], obj);
+    CHECK(objects[i]->Equals(obj));
   }
 
   heap_profiler->ClearObjectIds();
   for (int i = 0; i < kLength; i++) {
     v8::SnapshotObjectId id = heap_profiler->GetObjectId(objects[i]);
-    CHECK_EQ(v8::HeapProfiler::kUnknownObjectId, static_cast<int>(id));
+    CHECK_EQ(v8::HeapProfiler::kUnknownObjectId, id);
     v8::Handle<v8::Value> obj = heap_profiler->FindObjectById(ids[i]);
     CHECK(obj.IsEmpty());
   }
 }
 
 
 static void CheckChildrenIds(const v8::HeapSnapshot* snapshot,
                              const v8::HeapGraphNode* node,
                              int level, int max_level) {
   if (level > max_level) return;
   CHECK_EQ(node, snapshot->GetNodeById(node->GetId()));
   for (int i = 0, count = node->GetChildrenCount(); i < count; ++i) {
     const v8::HeapGraphEdge* prop = node->GetChild(i);
     const v8::HeapGraphNode* child =
         snapshot->GetNodeById(prop->GetToNode()->GetId());
-    CHECK_EQ_SNAPSHOT_OBJECT_ID(prop->GetToNode()->GetId(), child->GetId());
+    CHECK_EQ(prop->GetToNode()->GetId(), child->GetId());
     CHECK_EQ(prop->GetToNode(), child);
     CheckChildrenIds(snapshot, child, level + 1, max_level);
   }
 }
 
 
 TEST(HeapSnapshotGetNodeById) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("id"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* root = snapshot->GetRoot();
   CheckChildrenIds(snapshot, root, 0, 3);
   // Check a big id, which should not exist yet.
-  CHECK_EQ(NULL, snapshot->GetNodeById(0x1000000UL));
+  CHECK(!snapshot->GetNodeById(0x1000000UL));
 }
 
 
 TEST(HeapSnapshotGetSnapshotObjectId) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   CompileRun("globalObject = {};\n");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("get_snapshot_object_id"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* global_object =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "globalObject");
   CHECK(global_object);
 
   v8::Local<v8::Value> globalObjectHandle = env->Global()->Get(
       v8::String::NewFromUtf8(env->GetIsolate(), "globalObject"));
   CHECK(!globalObjectHandle.IsEmpty());
   CHECK(globalObjectHandle->IsObject());
 
   v8::SnapshotObjectId id = heap_profiler->GetObjectId(globalObjectHandle);
-  CHECK_NE(static_cast<int>(v8::HeapProfiler::kUnknownObjectId),
-           id);
-  CHECK_EQ(static_cast<int>(id), global_object->GetId());
+  CHECK_NE(v8::HeapProfiler::kUnknownObjectId, id);
+  CHECK_EQ(id, global_object->GetId());
 }
 
 
 TEST(HeapSnapshotUnknownSnapshotObjectId) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   CompileRun("globalObject = {};\n");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("unknown_object_id"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* node =
       snapshot->GetNodeById(v8::HeapProfiler::kUnknownObjectId);
-  CHECK_EQ(NULL, node);
+  CHECK(!node);
 }
 
 
 namespace {
 
 class TestActivityControl : public v8::ActivityControl {
  public:
   explicit TestActivityControl(int abort_count)
       : done_(0), total_(0), abort_count_(abort_count) {}
   ControlOption ReportProgressValue(int done, int total) {
@@ skipping 15 matching lines @@
 TEST(TakeHeapSnapshotAborting) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   const int snapshots_count = heap_profiler->GetSnapshotCount();
   TestActivityControl aborting_control(1);
   const v8::HeapSnapshot* no_snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("abort"),
                                      &aborting_control);
-  CHECK_EQ(NULL, no_snapshot);
+  CHECK(!no_snapshot);
   CHECK_EQ(snapshots_count, heap_profiler->GetSnapshotCount());
   CHECK_GT(aborting_control.total(), aborting_control.done());
 
   TestActivityControl control(-1);  // Don't abort.
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("full"),
                                      &control);
   CHECK(ValidateSnapshot(snapshot));
 
-  CHECK_NE(NULL, snapshot);
+  CHECK(snapshot);
   CHECK_EQ(snapshots_count + 1, heap_profiler->GetSnapshotCount());
   CHECK_EQ(control.total(), control.done());
   CHECK_GT(control.total(), 0);
 }
 
 
 namespace {
 
 class TestRetainedObjectInfo : public v8::RetainedObjectInfo {
  public:
@@ skipping 99 matching lines @@
   CHECK(ValidateSnapshot(snapshot));
 
   CHECK_EQ(3, TestRetainedObjectInfo::instances.length());
   for (int i = 0; i < TestRetainedObjectInfo::instances.length(); ++i) {
     CHECK(TestRetainedObjectInfo::instances[i]->disposed());
     delete TestRetainedObjectInfo::instances[i];
   }
 
   const v8::HeapGraphNode* native_group_aaa = GetNode(
       snapshot->GetRoot(), v8::HeapGraphNode::kSynthetic, "aaa-group");
-  CHECK_NE(NULL, native_group_aaa);
+  CHECK(native_group_aaa);
   CHECK_EQ(1, native_group_aaa->GetChildrenCount());
   const v8::HeapGraphNode* aaa = GetNode(
       native_group_aaa, v8::HeapGraphNode::kNative, "aaa / 100 entries");
-  CHECK_NE(NULL, aaa);
+  CHECK(aaa);
   CHECK_EQ(2, aaa->GetChildrenCount());
 
   const v8::HeapGraphNode* native_group_ccc = GetNode(
       snapshot->GetRoot(), v8::HeapGraphNode::kSynthetic, "ccc-group");
   const v8::HeapGraphNode* ccc = GetNode(
       native_group_ccc, v8::HeapGraphNode::kNative, "ccc");
-  CHECK_NE(NULL, ccc);
+  CHECK(ccc);
 
   const v8::HeapGraphNode* n_AAA = GetNode(
       aaa, v8::HeapGraphNode::kString, "AAA");
-  CHECK_NE(NULL, n_AAA);
+  CHECK(n_AAA);
   const v8::HeapGraphNode* n_BBB = GetNode(
       aaa, v8::HeapGraphNode::kString, "BBB");
-  CHECK_NE(NULL, n_BBB);
+  CHECK(n_BBB);
   CHECK_EQ(1, ccc->GetChildrenCount());
   const v8::HeapGraphNode* n_CCC = GetNode(
       ccc, v8::HeapGraphNode::kString, "CCC");
-  CHECK_NE(NULL, n_CCC);
+  CHECK(n_CCC);
 
   CHECK_EQ(aaa, GetProperty(n_AAA, v8::HeapGraphEdge::kInternal, "native"));
   CHECK_EQ(aaa, GetProperty(n_BBB, v8::HeapGraphEdge::kInternal, "native"));
   CHECK_EQ(ccc, GetProperty(n_CCC, v8::HeapGraphEdge::kInternal, "native"));
 }
 
 
 class GraphWithImplicitRefs {
  public:
   static const int kObjectsCount = 4;
   explicit GraphWithImplicitRefs(LocalContext* env) {
-    CHECK_EQ(NULL, instance_);
+    CHECK(!instance_);
     instance_ = this;
     isolate_ = (*env)->GetIsolate();
     for (int i = 0; i < kObjectsCount; i++) {
       objects_[i].Reset(isolate_, v8::Object::New(isolate_));
     }
     (*env)->Global()->Set(v8_str("root_object"),
                           v8::Local<v8::Value>::New(isolate_, objects_[0]));
   }
   ~GraphWithImplicitRefs() {
     instance_ = NULL;
@@ skipping 60 matching lines @@
 
 
 TEST(DeleteAllHeapSnapshots) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
   CHECK_EQ(0, heap_profiler->GetSnapshotCount());
   heap_profiler->DeleteAllHeapSnapshots();
   CHECK_EQ(0, heap_profiler->GetSnapshotCount());
-  CHECK_NE(NULL, heap_profiler->TakeHeapSnapshot(v8_str("1")));
+  CHECK(heap_profiler->TakeHeapSnapshot(v8_str("1")));
   CHECK_EQ(1, heap_profiler->GetSnapshotCount());
   heap_profiler->DeleteAllHeapSnapshots();
   CHECK_EQ(0, heap_profiler->GetSnapshotCount());
-  CHECK_NE(NULL, heap_profiler->TakeHeapSnapshot(v8_str("1")));
-  CHECK_NE(NULL, heap_profiler->TakeHeapSnapshot(v8_str("2")));
+  CHECK(heap_profiler->TakeHeapSnapshot(v8_str("1")));
+  CHECK(heap_profiler->TakeHeapSnapshot(v8_str("2")));
   CHECK_EQ(2, heap_profiler->GetSnapshotCount());
   heap_profiler->DeleteAllHeapSnapshots();
   CHECK_EQ(0, heap_profiler->GetSnapshotCount());
 }
 
 
 static const v8::HeapSnapshot* FindHeapSnapshot(v8::HeapProfiler* profiler,
                                                 unsigned uid) {
   int length = profiler->GetSnapshotCount();
   for (int i = 0; i < length; i++) {
     const v8::HeapSnapshot* snapshot = profiler->GetHeapSnapshot(i);
     if (snapshot->GetUid() == uid) {
       return snapshot;
     }
   }
   return NULL;
 }
 
 
 TEST(DeleteHeapSnapshot) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
   CHECK_EQ(0, heap_profiler->GetSnapshotCount());
   const v8::HeapSnapshot* s1 =
       heap_profiler->TakeHeapSnapshot(v8_str("1"));
 
-  CHECK_NE(NULL, s1);
+  CHECK(s1);
   CHECK_EQ(1, heap_profiler->GetSnapshotCount());
   unsigned uid1 = s1->GetUid();
   CHECK_EQ(s1, FindHeapSnapshot(heap_profiler, uid1));
   const_cast<v8::HeapSnapshot*>(s1)->Delete();
   CHECK_EQ(0, heap_profiler->GetSnapshotCount());
-  CHECK_EQ(NULL, FindHeapSnapshot(heap_profiler, uid1));
+  CHECK(!FindHeapSnapshot(heap_profiler, uid1));
 
   const v8::HeapSnapshot* s2 =
       heap_profiler->TakeHeapSnapshot(v8_str("2"));
-  CHECK_NE(NULL, s2);
+  CHECK(s2);
   CHECK_EQ(1, heap_profiler->GetSnapshotCount());
   unsigned uid2 = s2->GetUid();
   CHECK_NE(static_cast<int>(uid1), static_cast<int>(uid2));
   CHECK_EQ(s2, FindHeapSnapshot(heap_profiler, uid2));
   const v8::HeapSnapshot* s3 =
       heap_profiler->TakeHeapSnapshot(v8_str("3"));
-  CHECK_NE(NULL, s3);
+  CHECK(s3);
   CHECK_EQ(2, heap_profiler->GetSnapshotCount());
   unsigned uid3 = s3->GetUid();
   CHECK_NE(static_cast<int>(uid1), static_cast<int>(uid3));
   CHECK_EQ(s3, FindHeapSnapshot(heap_profiler, uid3));
   const_cast<v8::HeapSnapshot*>(s2)->Delete();
   CHECK_EQ(1, heap_profiler->GetSnapshotCount());
-  CHECK_EQ(NULL, FindHeapSnapshot(heap_profiler, uid2));
+  CHECK(!FindHeapSnapshot(heap_profiler, uid2));
   CHECK_EQ(s3, FindHeapSnapshot(heap_profiler, uid3));
   const_cast<v8::HeapSnapshot*>(s3)->Delete();
   CHECK_EQ(0, heap_profiler->GetSnapshotCount());
-  CHECK_EQ(NULL, FindHeapSnapshot(heap_profiler, uid3));
+  CHECK(!FindHeapSnapshot(heap_profiler, uid3));
 }
 
 
 class NameResolver : public v8::HeapProfiler::ObjectNameResolver {
  public:
   virtual const char* GetName(v8::Handle<v8::Object> object) {
     return "Global object name";
   }
 };
 
 
 TEST(GlobalObjectName) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
   CompileRun("document = { URL:\"abcdefgh\" };");
 
   NameResolver name_resolver;
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("document"),
       NULL,
       &name_resolver);
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
-  CHECK_NE(NULL, global);
-  CHECK_EQ("Object / Global object name" ,
-           const_cast<i::HeapEntry*>(
-               reinterpret_cast<const i::HeapEntry*>(global))->name());
+  CHECK(global);
+  CHECK_EQ(0,
+           strcmp("Object / Global object name",
+                  const_cast<i::HeapEntry*>(
+                      reinterpret_cast<const i::HeapEntry*>(global))->name()));
 }
 
 
 TEST(GlobalObjectFields) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   CompileRun("obj = {};");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* builtins =
       GetProperty(global, v8::HeapGraphEdge::kInternal, "builtins");
-  CHECK_NE(NULL, builtins);
+  CHECK(builtins);
   const v8::HeapGraphNode* native_context =
       GetProperty(global, v8::HeapGraphEdge::kInternal, "native_context");
-  CHECK_NE(NULL, native_context);
+  CHECK(native_context);
   const v8::HeapGraphNode* global_proxy =
       GetProperty(global, v8::HeapGraphEdge::kInternal, "global_proxy");
-  CHECK_NE(NULL, global_proxy);
+  CHECK(global_proxy);
 }
 
 
 TEST(NoHandleLeaks) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
   CompileRun("document = { URL:\"abcdefgh\" };");
 
   v8::Handle<v8::String> name(v8_str("leakz"));
   i::Isolate* isolate = CcTest::i_isolate();
   int count_before = i::HandleScope::NumberOfHandles(isolate);
   heap_profiler->TakeHeapSnapshot(name);
   int count_after = i::HandleScope::NumberOfHandles(isolate);
   CHECK_EQ(count_before, count_after);
 }
 
 
 TEST(NodesIteration) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("iteration"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
-  CHECK_NE(NULL, global);
+  CHECK(global);
   // Verify that we can find this object by iteration.
   const int nodes_count = snapshot->GetNodesCount();
   int count = 0;
   for (int i = 0; i < nodes_count; ++i) {
     if (snapshot->GetNode(i) == global)
       ++count;
   }
   CHECK_EQ(1, count);
 }
 
@@ skipping 128 matching lines @@
              "  return 42;\n"
              "});\n"
              "obj1.__defineSetter__('propWithSetter', function Z(value) {\n"
              "  return this.value_ = value;\n"
              "});\n");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("fastCaseAccessors"));
   CHECK(ValidateSnapshot(snapshot));
 
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
-  CHECK_NE(NULL, global);
+  CHECK(global);
   const v8::HeapGraphNode* obj1 =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "obj1");
-  CHECK_NE(NULL, obj1);
+  CHECK(obj1);
   const v8::HeapGraphNode* func;
   func = GetProperty(obj1, v8::HeapGraphEdge::kProperty, "get propWithGetter");
-  CHECK_NE(NULL, func);
+  CHECK(func);
   func = GetProperty(obj1, v8::HeapGraphEdge::kProperty, "set propWithGetter");
-  CHECK_EQ(NULL, func);
+  CHECK(!func);
   func = GetProperty(obj1, v8::HeapGraphEdge::kProperty, "set propWithSetter");
-  CHECK_NE(NULL, func);
+  CHECK(func);
   func = GetProperty(obj1, v8::HeapGraphEdge::kProperty, "get propWithSetter");
-  CHECK_EQ(NULL, func);
+  CHECK(!func);
 }
 
 
 TEST(FastCaseRedefinedAccessors) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
   CompileRun(
       "var obj1 = {};\n"
@@ skipping 12 matching lines @@
   v8::Local<v8::Object> js_global =
       env->Global()->GetPrototype().As<v8::Object>();
   i::Handle<i::JSObject> js_obj1 =
       v8::Utils::OpenHandle(*js_global->Get(v8_str("obj1")).As<v8::Object>());
   USE(js_obj1);
 
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("fastCaseAccessors"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
-  CHECK_NE(NULL, global);
+  CHECK(global);
   const v8::HeapGraphNode* obj1 =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "obj1");
-  CHECK_NE(NULL, obj1);
+  CHECK(obj1);
   const v8::HeapGraphNode* func;
   func = GetProperty(obj1, v8::HeapGraphEdge::kProperty, "get prop");
-  CHECK_NE(NULL, func);
+  CHECK(func);
   func = GetProperty(obj1, v8::HeapGraphEdge::kProperty, "set prop");
-  CHECK_NE(NULL, func);
+  CHECK(func);
 }
 
 
 TEST(SlowCaseAccessors) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
   CompileRun("var obj1 = {};\n"
              "for (var i = 0; i < 100; ++i) obj1['z' + i] = {};"
              "obj1.__defineGetter__('propWithGetter', function Y() {\n"
              "  return 42;\n"
              "});\n"
              "obj1.__defineSetter__('propWithSetter', function Z(value) {\n"
              "  return this.value_ = value;\n"
              "});\n");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("slowCaseAccessors"));
   CHECK(ValidateSnapshot(snapshot));
 
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
-  CHECK_NE(NULL, global);
+  CHECK(global);
   const v8::HeapGraphNode* obj1 =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "obj1");
-  CHECK_NE(NULL, obj1);
+  CHECK(obj1);
   const v8::HeapGraphNode* func;
   func = GetProperty(obj1, v8::HeapGraphEdge::kProperty, "get propWithGetter");
-  CHECK_NE(NULL, func);
+  CHECK(func);
   func = GetProperty(obj1, v8::HeapGraphEdge::kProperty, "set propWithGetter");
-  CHECK_EQ(NULL, func);
+  CHECK(!func);
   func = GetProperty(obj1, v8::HeapGraphEdge::kProperty, "set propWithSetter");
-  CHECK_NE(NULL, func);
+  CHECK(func);
   func = GetProperty(obj1, v8::HeapGraphEdge::kProperty, "get propWithSetter");
-  CHECK_EQ(NULL, func);
+  CHECK(!func);
 }
 
 
 TEST(HiddenPropertiesFastCase) {
   v8::Isolate* isolate = CcTest::isolate();
   LocalContext env;
   v8::HandleScope scope(isolate);
   v8::HeapProfiler* heap_profiler = isolate->GetHeapProfiler();
 
   CompileRun(
       "function C(x) { this.a = this; this.b = x; }\n"
       "c = new C(2012);\n");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("HiddenPropertiesFastCase1"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* c =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "c");
-  CHECK_NE(NULL, c);
+  CHECK(c);
   const v8::HeapGraphNode* hidden_props =
       GetProperty(c, v8::HeapGraphEdge::kInternal, "hidden_properties");
-  CHECK_EQ(NULL, hidden_props);
+  CHECK(!hidden_props);
 
   v8::Handle<v8::Value> cHandle =
       env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "c"));
   CHECK(!cHandle.IsEmpty() && cHandle->IsObject());
   cHandle->ToObject(isolate)->SetHiddenValue(v8_str("key"), v8_str("val"));
 
   snapshot = heap_profiler->TakeHeapSnapshot(
       v8_str("HiddenPropertiesFastCase2"));
   CHECK(ValidateSnapshot(snapshot));
   global = GetGlobalObject(snapshot);
   c = GetProperty(global, v8::HeapGraphEdge::kProperty, "c");
-  CHECK_NE(NULL, c);
+  CHECK(c);
   hidden_props = GetProperty(c, v8::HeapGraphEdge::kInternal,
       "hidden_properties");
-  CHECK_NE(NULL, hidden_props);
+  CHECK(hidden_props);
 }
 
 
 TEST(AccessorInfo) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
   CompileRun("function foo(x) { }\n");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("AccessorInfoTest"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* foo =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "foo");
-  CHECK_NE(NULL, foo);
+  CHECK(foo);
   const v8::HeapGraphNode* map =
       GetProperty(foo, v8::HeapGraphEdge::kInternal, "map");
-  CHECK_NE(NULL, map);
+  CHECK(map);
   const v8::HeapGraphNode* descriptors =
       GetProperty(map, v8::HeapGraphEdge::kInternal, "descriptors");
-  CHECK_NE(NULL, descriptors);
+  CHECK(descriptors);
   const v8::HeapGraphNode* length_name =
       GetProperty(descriptors, v8::HeapGraphEdge::kInternal, "2");
-  CHECK_NE(NULL, length_name);
-  CHECK_EQ("length", *v8::String::Utf8Value(length_name->GetName()));
+  CHECK(length_name);
+  CHECK_EQ(0, strcmp("length", *v8::String::Utf8Value(length_name->GetName())));
   const v8::HeapGraphNode* length_accessor =
       GetProperty(descriptors, v8::HeapGraphEdge::kInternal, "4");
-  CHECK_NE(NULL, length_accessor);
-  CHECK_EQ("system / ExecutableAccessorInfo",
-           *v8::String::Utf8Value(length_accessor->GetName()));
+  CHECK(length_accessor);
+  CHECK_EQ(0, strcmp("system / ExecutableAccessorInfo",
+                     *v8::String::Utf8Value(length_accessor->GetName())));
   const v8::HeapGraphNode* name =
       GetProperty(length_accessor, v8::HeapGraphEdge::kInternal, "name");
-  CHECK_NE(NULL, name);
+  CHECK(name);
   const v8::HeapGraphNode* getter =
       GetProperty(length_accessor, v8::HeapGraphEdge::kInternal, "getter");
-  CHECK_NE(NULL, getter);
+  CHECK(getter);
   const v8::HeapGraphNode* setter =
       GetProperty(length_accessor, v8::HeapGraphEdge::kInternal, "setter");
-  CHECK_NE(NULL, setter);
+  CHECK(setter);
 }
 
 
 bool HasWeakEdge(const v8::HeapGraphNode* node) {
   for (int i = 0; i < node->GetChildrenCount(); ++i) {
     const v8::HeapGraphEdge* handle_edge = node->GetChild(i);
     if (handle_edge->GetType() == v8::HeapGraphEdge::kWeak) return true;
   }
   return false;
 }
 
 
 bool HasWeakGlobalHandle() {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HeapProfiler* heap_profiler = isolate->GetHeapProfiler();
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("weaks"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* gc_roots = GetNode(
       snapshot->GetRoot(), v8::HeapGraphNode::kSynthetic, "(GC roots)");
-  CHECK_NE(NULL, gc_roots);
+  CHECK(gc_roots);
   const v8::HeapGraphNode* global_handles = GetNode(
       gc_roots, v8::HeapGraphNode::kSynthetic, "(Global handles)");
-  CHECK_NE(NULL, global_handles);
+  CHECK(global_handles);
   return HasWeakEdge(global_handles);
 }
 
 
 static void PersistentHandleCallback(
     const v8::WeakCallbackData<v8::Object, v8::Persistent<v8::Object> >& data) {
   data.GetParameter()->Reset();
   delete data.GetParameter();
 }
 
@@ skipping 16 matching lines @@
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
   CompileRun(
       "fun = (function (x) { return function () { return x + 1; } })(1);");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("fun"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
-  CHECK_NE(NULL, global);
+  CHECK(global);
   const v8::HeapGraphNode* fun =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "fun");
   CHECK(!HasWeakEdge(fun));
   const v8::HeapGraphNode* shared =
       GetProperty(fun, v8::HeapGraphEdge::kInternal, "shared");
   CHECK(!HasWeakEdge(shared));
 }
 
 
 TEST(NoDebugObjectInSnapshot) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
   CHECK(CcTest::i_isolate()->debug()->Load());
   CompileRun("foo = {};");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* root = snapshot->GetRoot();
   int globals_count = 0;
   for (int i = 0; i < root->GetChildrenCount(); ++i) {
     const v8::HeapGraphEdge* edge = root->GetChild(i);
     if (edge->GetType() == v8::HeapGraphEdge::kShortcut) {
       ++globals_count;
       const v8::HeapGraphNode* global = edge->GetToNode();
       const v8::HeapGraphNode* foo =
           GetProperty(global, v8::HeapGraphEdge::kProperty, "foo");
-      CHECK_NE(NULL, foo);
+      CHECK(foo);
     }
   }
   CHECK_EQ(1, globals_count);
 }
 
 
 TEST(AllStrongGcRootsHaveNames) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
 
   CompileRun("foo = {};");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* gc_roots = GetNode(
       snapshot->GetRoot(), v8::HeapGraphNode::kSynthetic, "(GC roots)");
-  CHECK_NE(NULL, gc_roots);
+  CHECK(gc_roots);
   const v8::HeapGraphNode* strong_roots = GetNode(
       gc_roots, v8::HeapGraphNode::kSynthetic, "(Strong roots)");
-  CHECK_NE(NULL, strong_roots);
+  CHECK(strong_roots);
   for (int i = 0; i < strong_roots->GetChildrenCount(); ++i) {
     const v8::HeapGraphEdge* edge = strong_roots->GetChild(i);
     CHECK_EQ(v8::HeapGraphEdge::kInternal, edge->GetType());
     v8::String::Utf8Value name(edge->GetName());
     CHECK(isalpha(**name));
   }
 }
 
 
 TEST(NoRefsToNonEssentialEntries) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   CompileRun("global_object = {};\n");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* global_object =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "global_object");
-  CHECK_NE(NULL, global_object);
+  CHECK(global_object);
   const v8::HeapGraphNode* properties =
       GetProperty(global_object, v8::HeapGraphEdge::kInternal, "properties");
-  CHECK_EQ(NULL, properties);
+  CHECK(!properties);
   const v8::HeapGraphNode* elements =
       GetProperty(global_object, v8::HeapGraphEdge::kInternal, "elements");
-  CHECK_EQ(NULL, elements);
+  CHECK(!elements);
 }
 
 
 TEST(MapHasDescriptorsAndTransitions) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   CompileRun("obj = { a: 10 };\n");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* global_object =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "obj");
-  CHECK_NE(NULL, global_object);
+  CHECK(global_object);
 
   const v8::HeapGraphNode* map =
       GetProperty(global_object, v8::HeapGraphEdge::kInternal, "map");
-  CHECK_NE(NULL, map);
+  CHECK(map);
   const v8::HeapGraphNode* own_descriptors = GetProperty(
       map, v8::HeapGraphEdge::kInternal, "descriptors");
-  CHECK_NE(NULL, own_descriptors);
+  CHECK(own_descriptors);
   const v8::HeapGraphNode* own_transitions = GetProperty(
       map, v8::HeapGraphEdge::kInternal, "transitions");
-  CHECK_EQ(NULL, own_transitions);
+  CHECK(!own_transitions);
 }
 
 
 TEST(ManyLocalsInSharedContext) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   int num_objects = 6000;
   CompileRun(
       "var n = 6000;"
       "var result = [];"
       "result.push('(function outer() {');"
       "for (var i = 0; i < n; i++) {"
       "    var f = 'function f_' + i + '() { ';"
       "    if (i > 0)"
       "        f += 'f_' + (i - 1) + '();';"
       "    f += ' }';"
       "    result.push(f);"
       "}"
       "result.push('return f_' + (n - 1) + ';');"
       "result.push('})()');"
       "var ok = eval(result.join('\\n'));");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
   CHECK(ValidateSnapshot(snapshot));
 
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
-  CHECK_NE(NULL, global);
+  CHECK(global);
   const v8::HeapGraphNode* ok_object =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "ok");
-  CHECK_NE(NULL, ok_object);
+  CHECK(ok_object);
   const v8::HeapGraphNode* context_object =
       GetProperty(ok_object, v8::HeapGraphEdge::kInternal, "context");
-  CHECK_NE(NULL, context_object);
+  CHECK(context_object);
   // Check the objects are not duplicated in the context.
   CHECK_EQ(v8::internal::Context::MIN_CONTEXT_SLOTS + num_objects - 1,
            context_object->GetChildrenCount());
   // Check all the objects have got their names.
   // ... well check just every 15th because otherwise it's too slow in debug.
   for (int i = 0; i < num_objects - 1; i += 15) {
     i::EmbeddedVector<char, 100> var_name;
     i::SNPrintF(var_name, "f_%d", i);
     const v8::HeapGraphNode* f_object = GetProperty(
         context_object, v8::HeapGraphEdge::kContextVariable, var_name.start());
-    CHECK_NE(NULL, f_object);
+    CHECK(f_object);
   }
 }
 
 
 TEST(AllocationSitesAreVisible) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   v8::HeapProfiler* heap_profiler = isolate->GetHeapProfiler();
   CompileRun(
       "fun = function () { var a = [3, 2, 1]; return a; }\n"
       "fun();");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
   CHECK(ValidateSnapshot(snapshot));
 
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
-  CHECK_NE(NULL, global);
+  CHECK(global);
   const v8::HeapGraphNode* fun_code =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "fun");
-  CHECK_NE(NULL, fun_code);
+  CHECK(fun_code);
   const v8::HeapGraphNode* literals =
       GetProperty(fun_code, v8::HeapGraphEdge::kInternal, "literals");
-  CHECK_NE(NULL, literals);
+  CHECK(literals);
   CHECK_EQ(v8::HeapGraphNode::kArray, literals->GetType());
   CHECK_EQ(2, literals->GetChildrenCount());
 
   // The second value in the literals array should be the boilerplate,
   // after an AllocationSite.
   const v8::HeapGraphEdge* prop = literals->GetChild(1);
   const v8::HeapGraphNode* allocation_site = prop->GetToNode();
   v8::String::Utf8Value name(allocation_site->GetName());
-  CHECK_EQ("system / AllocationSite", *name);
+  CHECK_EQ(0, strcmp("system / AllocationSite", *name));
   const v8::HeapGraphNode* transition_info =
       GetProperty(allocation_site, v8::HeapGraphEdge::kInternal,
                   "transition_info");
-  CHECK_NE(NULL, transition_info);
+  CHECK(transition_info);
 
   const v8::HeapGraphNode* elements =
       GetProperty(transition_info, v8::HeapGraphEdge::kInternal,
                   "elements");
-  CHECK_NE(NULL, elements);
+  CHECK(elements);
   CHECK_EQ(v8::HeapGraphNode::kArray, elements->GetType());
   CHECK_EQ(v8::internal::FixedArray::SizeFor(3),
            static_cast<int>(elements->GetShallowSize()));
 
   v8::Handle<v8::Value> array_val =
       heap_profiler->FindObjectById(transition_info->GetId());
   CHECK(array_val->IsArray());
   v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(array_val);
   // Verify the array is "a" in the code above.
-  CHECK_EQ(3, array->Length());
-  CHECK_EQ(v8::Integer::New(isolate, 3),
-           array->Get(v8::Integer::New(isolate, 0)));
-  CHECK_EQ(v8::Integer::New(isolate, 2),
-           array->Get(v8::Integer::New(isolate, 1)));
-  CHECK_EQ(v8::Integer::New(isolate, 1),
-           array->Get(v8::Integer::New(isolate, 2)));
+  CHECK_EQ(3u, array->Length());
+  CHECK(v8::Integer::New(isolate, 3)
+            ->Equals(array->Get(v8::Integer::New(isolate, 0))));
+  CHECK(v8::Integer::New(isolate, 2)
+            ->Equals(array->Get(v8::Integer::New(isolate, 1))));
+  CHECK(v8::Integer::New(isolate, 1)
+            ->Equals(array->Get(v8::Integer::New(isolate, 2))));
 }
 
 
 TEST(JSFunctionHasCodeLink) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   CompileRun("function foo(x, y) { return x + y; }\n");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* foo_func =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "foo");
-  CHECK_NE(NULL, foo_func);
+  CHECK(foo_func);
   const v8::HeapGraphNode* code =
       GetProperty(foo_func, v8::HeapGraphEdge::kInternal, "code");
-  CHECK_NE(NULL, code);
+  CHECK(code);
 }
 
 
 static const v8::HeapGraphNode* GetNodeByPath(const v8::HeapSnapshot* snapshot,
                                               const char* path[],
                                               int depth) {
   const v8::HeapGraphNode* node = snapshot->GetRoot();
   for (int current_depth = 0; current_depth < depth; ++current_depth) {
     int i, count = node->GetChildrenCount();
     for (i = 0; i < count; ++i) {
@@ skipping 24 matching lines @@
   CHECK(ValidateSnapshot(snapshot));
 
   const char* stub_path[] = {
     "::(GC roots)",
     "::(Strong roots)",
     "code_stubs::",
     "::(ArraySingleArgumentConstructorStub code)"
   };
   const v8::HeapGraphNode* node = GetNodeByPath(snapshot,
       stub_path, arraysize(stub_path));
-  CHECK_NE(NULL, node);
+  CHECK(node);
 
   const char* builtin_path1[] = {
     "::(GC roots)",
     "::(Builtins)",
     "::(KeyedLoadIC_Generic builtin)"
   };
   node = GetNodeByPath(snapshot, builtin_path1, arraysize(builtin_path1));
-  CHECK_NE(NULL, node);
+  CHECK(node);
 
   const char* builtin_path2[] = {"::(GC roots)", "::(Builtins)",
                                  "::(CompileLazy builtin)"};
   node = GetNodeByPath(snapshot, builtin_path2, arraysize(builtin_path2));
-  CHECK_NE(NULL, node);
+  CHECK(node);
   v8::String::Utf8Value node_name(node->GetName());
-  CHECK_EQ("(CompileLazy builtin)", *node_name);
+  CHECK_EQ(0, strcmp("(CompileLazy builtin)", *node_name));
 }
 
 
 static const char* record_trace_tree_source =
 "var topFunctions = [];\n"
 "var global = this;\n"
 "function generateFunctions(width, depth) {\n"
 "  var script = [];\n"
 "  for (var i = 0; i < width; i++) {\n"
 "    for (var j = 0; j < depth; j++) {\n"
@@ skipping 62 matching lines @@
   CompileRun(
     "var a = [];\n"
     "for (var i = 0; i < 5; ++i)\n"
     "    a[i] = i;\n"
     "for (var i = 0; i < 3; ++i)\n"
     "    a.shift();\n");
 
   const char* names[] = {""};
   AllocationTracker* tracker =
       reinterpret_cast<i::HeapProfiler*>(heap_profiler)->allocation_tracker();
-  CHECK_NE(NULL, tracker);
+  CHECK(tracker);
   // Resolve all function locations.
   tracker->PrepareForSerialization();
   // Print for better diagnostics in case of failure.
   tracker->trace_tree()->Print(tracker);
 
   AllocationTraceNode* node =
       FindNode(tracker, Vector<const char*>(names, arraysize(names)));
-  CHECK_NE(NULL, node);
-  CHECK_GE(node->allocation_count(), 2);
-  CHECK_GE(node->allocation_size(), 4 * 5);
+  CHECK(node);
+  CHECK_GE(node->allocation_count(), 2u);
+  CHECK_GE(node->allocation_size(), 4u * 5u);
   heap_profiler->StopTrackingHeapObjects();
 }
 
 
 TEST(TrackHeapAllocations) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   LocalContext env;
 
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   heap_profiler->StartTrackingHeapObjects(true);
 
   CompileRun(record_trace_tree_source);
 
   AllocationTracker* tracker =
       reinterpret_cast<i::HeapProfiler*>(heap_profiler)->allocation_tracker();
-  CHECK_NE(NULL, tracker);
+  CHECK(tracker);
   // Resolve all function locations.
   tracker->PrepareForSerialization();
   // Print for better diagnostics in case of failure.
   tracker->trace_tree()->Print(tracker);
 
   const char* names[] = {"", "start", "f_0_0", "f_0_1", "f_0_2"};
   AllocationTraceNode* node =
       FindNode(tracker, Vector<const char*>(names, arraysize(names)));
-  CHECK_NE(NULL, node);
-  CHECK_GE(node->allocation_count(), 100);
+  CHECK(node);
+  CHECK_GE(node->allocation_count(), 100u);
   CHECK_GE(node->allocation_size(), 4 * node->allocation_count());
   heap_profiler->StopTrackingHeapObjects();
 }
 
 
 static const char* inline_heap_allocation_source =
 "function f_0(x) {\n"
 "  return f_1(x+1);\n"
 "}\n"
 "%NeverOptimizeFunction(f_0);\n"
@@ skipping 19 matching lines @@
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   const char* names[] = {"", "start", "f_0", "f_1"};
   // First check that normally all allocations are recorded.
   {
     heap_profiler->StartTrackingHeapObjects(true);
 
     CompileRun(inline_heap_allocation_source);
 
     AllocationTracker* tracker =
         reinterpret_cast<i::HeapProfiler*>(heap_profiler)->allocation_tracker();
-    CHECK_NE(NULL, tracker);
+    CHECK(tracker);
     // Resolve all function locations.
     tracker->PrepareForSerialization();
     // Print for better diagnostics in case of failure.
     tracker->trace_tree()->Print(tracker);
 
     AllocationTraceNode* node =
         FindNode(tracker, Vector<const char*>(names, arraysize(names)));
-    CHECK_NE(NULL, node);
-    CHECK_GE(node->allocation_count(), 100);
+    CHECK(node);
+    CHECK_GE(node->allocation_count(), 100u);
     CHECK_GE(node->allocation_size(), 4 * node->allocation_count());
     heap_profiler->StopTrackingHeapObjects();
   }
 
   {
     heap_profiler->StartTrackingHeapObjects(true);
 
     // Now check that not all allocations are tracked if we manually reenable
     // inline allocations.
     CHECK(CcTest::heap()->inline_allocation_disabled());
     CcTest::heap()->EnableInlineAllocation();
 
     CompileRun(inline_heap_allocation_source);
 
     AllocationTracker* tracker =
         reinterpret_cast<i::HeapProfiler*>(heap_profiler)->allocation_tracker();
-    CHECK_NE(NULL, tracker);
+    CHECK(tracker);
     // Resolve all function locations.
     tracker->PrepareForSerialization();
     // Print for better diagnostics in case of failure.
     tracker->trace_tree()->Print(tracker);
 
     AllocationTraceNode* node =
         FindNode(tracker, Vector<const char*>(names, arraysize(names)));
-    CHECK_NE(NULL, node);
-    CHECK_LT(node->allocation_count(), 100);
+    CHECK(node);
+    CHECK_LT(node->allocation_count(), 100u);
 
     CcTest::heap()->DisableInlineAllocation();
     heap_profiler->StopTrackingHeapObjects();
   }
 }
 
 
 TEST(TrackV8ApiAllocation) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   LocalContext env;
 
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   const char* names[] = { "(V8 API)" };
   heap_profiler->StartTrackingHeapObjects(true);
 
   v8::Handle<v8::Object> o1 = v8::Object::New(env->GetIsolate());
   o1->Clone();
 
   AllocationTracker* tracker =
       reinterpret_cast<i::HeapProfiler*>(heap_profiler)->allocation_tracker();
-  CHECK_NE(NULL, tracker);
+  CHECK(tracker);
   // Resolve all function locations.
   tracker->PrepareForSerialization();
   // Print for better diagnostics in case of failure.
   tracker->trace_tree()->Print(tracker);
 
   AllocationTraceNode* node =
       FindNode(tracker, Vector<const char*>(names, arraysize(names)));
-  CHECK_NE(NULL, node);
-  CHECK_GE(node->allocation_count(), 2);
+  CHECK(node);
+  CHECK_GE(node->allocation_count(), 2u);
   CHECK_GE(node->allocation_size(), 4 * node->allocation_count());
   heap_profiler->StopTrackingHeapObjects();
 }
 
 
 TEST(ArrayBufferAndArrayBufferView) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   CompileRun("arr1 = new Uint32Array(100);\n");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* arr1_obj =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "arr1");
-  CHECK_NE(NULL, arr1_obj);
+  CHECK(arr1_obj);
   const v8::HeapGraphNode* arr1_buffer =
       GetProperty(arr1_obj, v8::HeapGraphEdge::kInternal, "buffer");
-  CHECK_NE(NULL, arr1_buffer);
+  CHECK(arr1_buffer);
   const v8::HeapGraphNode* first_view =
       GetProperty(arr1_buffer, v8::HeapGraphEdge::kWeak, "weak_first_view");
-  CHECK_NE(NULL, first_view);
+  CHECK(first_view);
   const v8::HeapGraphNode* backing_store =
       GetProperty(arr1_buffer, v8::HeapGraphEdge::kInternal, "backing_store");
-  CHECK_NE(NULL, backing_store);
+  CHECK(backing_store);
   CHECK_EQ(400, static_cast<int>(backing_store->GetShallowSize()));
 }
 
 
 static int GetRetainersCount(const v8::HeapSnapshot* snapshot,
                              const v8::HeapGraphNode* node) {
   int count = 0;
   for (int i = 0, l = snapshot->GetNodesCount(); i < l; ++i) {
     const v8::HeapGraphNode* parent = snapshot->GetNode(i);
     for (int j = 0, l2 = parent->GetChildrenCount(); j < l2; ++j) {
@@ skipping 29 matching lines @@
 
   v8::Handle<v8::Value> result = CompileRun("ab2.byteLength");
   CHECK_EQ(1024, result->Int32Value());
 
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* ab1_node =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "ab1");
-  CHECK_NE(NULL, ab1_node);
+  CHECK(ab1_node);
   const v8::HeapGraphNode* ab1_data =
       GetProperty(ab1_node, v8::HeapGraphEdge::kInternal, "backing_store");
-  CHECK_NE(NULL, ab1_data);
+  CHECK(ab1_data);
   const v8::HeapGraphNode* ab2_node =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "ab2");
-  CHECK_NE(NULL, ab2_node);
+  CHECK(ab2_node);
   const v8::HeapGraphNode* ab2_data =
       GetProperty(ab2_node, v8::HeapGraphEdge::kInternal, "backing_store");
-  CHECK_NE(NULL, ab2_data);
+  CHECK(ab2_data);
   CHECK_EQ(ab1_data, ab2_data);
   CHECK_EQ(2, GetRetainersCount(snapshot, ab1_data));
   free(data);
 }
 
 
 TEST(BoxObject) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   LocalContext env;
   v8::Handle<v8::Object> global_proxy = env->Global();
   v8::Handle<v8::Object> global = global_proxy->GetPrototype().As<v8::Object>();
 
   i::Factory* factory = CcTest::i_isolate()->factory();
   i::Handle<i::String> string = factory->NewStringFromStaticChars("string");
   i::Handle<i::Object> box = factory->NewBox(string);
   global->Set(0, v8::ToApiHandle<v8::Object>(box));
 
   v8::HeapProfiler* heap_profiler = isolate->GetHeapProfiler();
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global_node = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* box_node =
       GetProperty(global_node, v8::HeapGraphEdge::kElement, "0");
-  CHECK_NE(NULL, box_node);
+  CHECK(box_node);
   v8::String::Utf8Value box_node_name(box_node->GetName());
-  CHECK_EQ("system / Box", *box_node_name);
+  CHECK_EQ(0, strcmp("system / Box", *box_node_name));
   const v8::HeapGraphNode* box_value =
       GetProperty(box_node, v8::HeapGraphEdge::kInternal, "value");
-  CHECK_NE(NULL, box_value);
+  CHECK(box_value);
 }
 
 
 TEST(WeakContainers) {
   i::FLAG_allow_natives_syntax = true;
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   if (!CcTest::i_isolate()->use_crankshaft()) return;
   v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
   CompileRun(
       "function foo(a) { return a.x; }\n"
       "obj = {x : 123};\n"
       "foo(obj);\n"
       "foo(obj);\n"
       "%OptimizeFunctionOnNextCall(foo);\n"
       "foo(obj);\n");
   const v8::HeapSnapshot* snapshot =
       heap_profiler->TakeHeapSnapshot(v8_str("snapshot"));
   CHECK(ValidateSnapshot(snapshot));
   const v8::HeapGraphNode* global = GetGlobalObject(snapshot);
   const v8::HeapGraphNode* obj =
       GetProperty(global, v8::HeapGraphEdge::kProperty, "obj");
-  CHECK_NE(NULL, obj);
+  CHECK(obj);
   const v8::HeapGraphNode* map =
       GetProperty(obj, v8::HeapGraphEdge::kInternal, "map");
-  CHECK_NE(NULL, map);
+  CHECK(map);
   const v8::HeapGraphNode* dependent_code =
       GetProperty(map, v8::HeapGraphEdge::kInternal, "dependent_code");
   if (!dependent_code) return;
   int count = dependent_code->GetChildrenCount();
   CHECK_NE(0, count);
   for (int i = 0; i < count; ++i) {
     const v8::HeapGraphEdge* prop = dependent_code->GetChild(i);
     CHECK_EQ(v8::HeapGraphEdge::kWeak, prop->GetType());
   }
 }
 
 
 static inline i::Address ToAddress(int n) {
   return reinterpret_cast<i::Address>(n);
 }
 
 
 TEST(AddressToTraceMap) {
   i::AddressToTraceMap map;
 
-  CHECK_EQ(0, map.GetTraceNodeId(ToAddress(150)));
+  CHECK_EQ(0u, map.GetTraceNodeId(ToAddress(150)));
 
   // [0x100, 0x200) -> 1
   map.AddRange(ToAddress(0x100), 0x100, 1U);
-  CHECK_EQ(0, map.GetTraceNodeId(ToAddress(0x50)));
-  CHECK_EQ(1, map.GetTraceNodeId(ToAddress(0x100)));
-  CHECK_EQ(1, map.GetTraceNodeId(ToAddress(0x150)));
-  CHECK_EQ(0, map.GetTraceNodeId(ToAddress(0x100 + 0x100)));
-  CHECK_EQ(1, static_cast<int>(map.size()));
+  CHECK_EQ(0u, map.GetTraceNodeId(ToAddress(0x50)));
+  CHECK_EQ(1u, map.GetTraceNodeId(ToAddress(0x100)));
+  CHECK_EQ(1u, map.GetTraceNodeId(ToAddress(0x150)));
+  CHECK_EQ(0u, map.GetTraceNodeId(ToAddress(0x100 + 0x100)));
+  CHECK_EQ(1u, map.size());
 
   // [0x100, 0x200) -> 1, [0x200, 0x300) -> 2
   map.AddRange(ToAddress(0x200), 0x100, 2U);
-  CHECK_EQ(2, map.GetTraceNodeId(ToAddress(0x2a0)));
-  CHECK_EQ(2, static_cast<int>(map.size()));
+  CHECK_EQ(2u, map.GetTraceNodeId(ToAddress(0x2a0)));
+  CHECK_EQ(2u, map.size());
 
   // [0x100, 0x180) -> 1, [0x180, 0x280) -> 3, [0x280, 0x300) -> 2
   map.AddRange(ToAddress(0x180), 0x100, 3U);
-  CHECK_EQ(1, map.GetTraceNodeId(ToAddress(0x17F)));
-  CHECK_EQ(2, map.GetTraceNodeId(ToAddress(0x280)));
-  CHECK_EQ(3, map.GetTraceNodeId(ToAddress(0x180)));
-  CHECK_EQ(3, static_cast<int>(map.size()));
+  CHECK_EQ(1u, map.GetTraceNodeId(ToAddress(0x17F)));
+  CHECK_EQ(2u, map.GetTraceNodeId(ToAddress(0x280)));
+  CHECK_EQ(3u, map.GetTraceNodeId(ToAddress(0x180)));
+  CHECK_EQ(3u, map.size());
 
   // [0x100, 0x180) -> 1, [0x180, 0x280) -> 3, [0x280, 0x300) -> 2,
   // [0x400, 0x500) -> 4
   map.AddRange(ToAddress(0x400), 0x100, 4U);
-  CHECK_EQ(1, map.GetTraceNodeId(ToAddress(0x17F)));
-  CHECK_EQ(2, map.GetTraceNodeId(ToAddress(0x280)));
-  CHECK_EQ(3, map.GetTraceNodeId(ToAddress(0x180)));
-  CHECK_EQ(4, map.GetTraceNodeId(ToAddress(0x450)));
-  CHECK_EQ(0, map.GetTraceNodeId(ToAddress(0x500)));
-  CHECK_EQ(0, map.GetTraceNodeId(ToAddress(0x350)));
-  CHECK_EQ(4, static_cast<int>(map.size()));
+  CHECK_EQ(1u, map.GetTraceNodeId(ToAddress(0x17F)));
+  CHECK_EQ(2u, map.GetTraceNodeId(ToAddress(0x280)));
+  CHECK_EQ(3u, map.GetTraceNodeId(ToAddress(0x180)));
+  CHECK_EQ(4u, map.GetTraceNodeId(ToAddress(0x450)));
+  CHECK_EQ(0u, map.GetTraceNodeId(ToAddress(0x500)));
+  CHECK_EQ(0u, map.GetTraceNodeId(ToAddress(0x350)));
+  CHECK_EQ(4u, map.size());
 
   // [0x100, 0x180) -> 1, [0x180, 0x200) -> 3, [0x200, 0x600) -> 5
   map.AddRange(ToAddress(0x200), 0x400, 5U);
-  CHECK_EQ(5, map.GetTraceNodeId(ToAddress(0x200)));
-  CHECK_EQ(5, map.GetTraceNodeId(ToAddress(0x400)));
-  CHECK_EQ(3, static_cast<int>(map.size()));
+  CHECK_EQ(5u, map.GetTraceNodeId(ToAddress(0x200)));
+  CHECK_EQ(5u, map.GetTraceNodeId(ToAddress(0x400)));
+  CHECK_EQ(3u, map.size());
 
   // [0x100, 0x180) -> 1, [0x180, 0x200) -> 7, [0x200, 0x600) ->5
   map.AddRange(ToAddress(0x180), 0x80, 6U);
   map.AddRange(ToAddress(0x180), 0x80, 7U);
-  CHECK_EQ(7, map.GetTraceNodeId(ToAddress(0x180)));
-  CHECK_EQ(5, map.GetTraceNodeId(ToAddress(0x200)));
-  CHECK_EQ(3, static_cast<int>(map.size()));
+  CHECK_EQ(7u, map.GetTraceNodeId(ToAddress(0x180)));
+  CHECK_EQ(5u, map.GetTraceNodeId(ToAddress(0x200)));
+  CHECK_EQ(3u, map.size());
 
   map.Clear();
-  CHECK_EQ(0, static_cast<int>(map.size()));
-  CHECK_EQ(0, map.GetTraceNodeId(ToAddress(0x400)));
+  CHECK_EQ(0u, map.size());
+  CHECK_EQ(0u, map.GetTraceNodeId(ToAddress(0x400)));
 }