CSE2410 Fall 2014 Bounce

// 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

//       with the distribution.

//     * Neither the name of Google Inc. nor the names of its

//       contributors may be used to endorse or promote products derived

//       from this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

// Tests for heap profiler

#include <ctype.h>

#include "v8.h"

#include "allocation-tracker.h"

#include "cctest.h"

#include "hashmap.h"

#include "heap-profiler.h"

#include "snapshot.h"

#include "debug.h"

#include "utils-inl.h"

#include "../include/v8-profiler.h"

using i::AllocationTraceNode;

using i::AllocationTraceTree;

using i::AllocationTracker;

using i::HashMap;

using i::Vector;

namespace {

class NamedEntriesDetector {

 public:

  NamedEntriesDetector()

      : has_A2(false), has_B2(false), has_C2(false) {

  }

  void CheckEntry(i::HeapEntry* entry) {

    if (strcmp(entry->name(), "A2") == 0) has_A2 = true;

    if (strcmp(entry->name(), "B2") == 0) has_B2 = true;

    if (strcmp(entry->name(), "C2") == 0) has_C2 = true;

  }

  static bool AddressesMatch(void* key1, void* key2) {

    return key1 == key2;

  }

  void CheckAllReachables(i::HeapEntry* root) {

    i::HashMap visited(AddressesMatch);

    i::List<i::HeapEntry*> list(10);

    list.Add(root);

    CheckEntry(root);

    while (!list.is_empty()) {

      i::HeapEntry* entry = list.RemoveLast();

      i::Vector<i::HeapGraphEdge*> children = entry->children();

      for (int i = 0; i < children.length(); ++i) {

        if (children[i]->type() == i::HeapGraphEdge::kShortcut) continue;

        i::HeapEntry* child = children[i]->to();

        i::HashMap::Entry* entry = visited.Lookup(

            reinterpret_cast<void*>(child),

            static_cast<uint32_t>(reinterpret_cast<uintptr_t>(child)),

            true);

        if (entry->value)

          continue;

        entry->value = reinterpret_cast<void*>(1);

        list.Add(child);

        CheckEntry(child);

      }

    }

  }

  bool has_A2;

  bool has_B2;

  bool has_C2;

};

}  // namespace

static const v8::HeapGraphNode* GetGlobalObject(

    const v8::HeapSnapshot* snapshot) {

  CHECK_EQ(2, snapshot->GetRoot()->GetChildrenCount());

  // The 0th-child is (GC Roots), 1st is the user root.

  const v8::HeapGraphNode* global_obj =

      snapshot->GetRoot()->GetChild(1)->GetToNode();

  CHECK_EQ(0, strncmp("Object", const_cast<i::HeapEntry*>(

      reinterpret_cast<const i::HeapEntry*>(global_obj))->name(), 6));

  return global_obj;

}

static const v8::HeapGraphNode* GetProperty(const v8::HeapGraphNode* node,

                                            v8::HeapGraphEdge::Type type,

                                            const char* name) {

  for (int i = 0, count = node->GetChildrenCount(); i < count; ++i) {

    const v8::HeapGraphEdge* prop = node->GetChild(i);

    v8::String::Utf8Value prop_name(prop->GetName());

    if (prop->GetType() == type && strcmp(name, *prop_name) == 0)

      return prop->GetToNode();

  }

  return NULL;

}

static bool HasString(const v8::HeapGraphNode* node, const char* contents) {

  for (int i = 0, count = node->GetChildrenCount(); i < count; ++i) {

    const v8::HeapGraphEdge* prop = node->GetChild(i);

    const v8::HeapGraphNode* node = prop->GetToNode();

    if (node->GetType() == v8::HeapGraphNode::kString) {

      v8::String::Utf8Value node_name(node->GetName());

      if (strcmp(contents, *node_name) == 0) return true;

    }

  }

  return false;

}

static bool AddressesMatch(void* key1, void* key2) {

  return key1 == key2;

}

// Check that snapshot has no unretained entries except root.

static bool ValidateSnapshot(const v8::HeapSnapshot* snapshot, int depth = 3) {

  i::HeapSnapshot* heap_snapshot = const_cast<i::HeapSnapshot*>(

      reinterpret_cast<const i::HeapSnapshot*>(snapshot));

  i::HashMap visited(AddressesMatch);

  i::List<i::HeapGraphEdge>& edges = heap_snapshot->edges();

  for (int i = 0; i < edges.length(); ++i) {

    i::HashMap::Entry* entry = visited.Lookup(

        reinterpret_cast<void*>(edges[i].to()),

        static_cast<uint32_t>(reinterpret_cast<uintptr_t>(edges[i].to())),

        true);

    uint32_t ref_count = static_cast<uint32_t>(

        reinterpret_cast<uintptr_t>(entry->value));

    entry->value = reinterpret_cast<void*>(ref_count + 1);

  }

  uint32_t unretained_entries_count = 0;

  i::List<i::HeapEntry>& entries = heap_snapshot->entries();

  for (int i = 0; i < entries.length(); ++i) {

    i::HashMap::Entry* entry = visited.Lookup(

        reinterpret_cast<void*>(&entries[i]),

        static_cast<uint32_t>(reinterpret_cast<uintptr_t>(&entries[i])),

        false);

    if (!entry && entries[i].id() != 1) {

        entries[i].Print("entry with no retainer", "", depth, 0);

        ++unretained_entries_count;

    }

  }

  return unretained_entries_count == 0;

}

TEST(HeapSnapshot) {

  LocalContext env2;

  v8::HandleScope scope(env2->GetIsolate());

  v8::HeapProfiler* heap_profiler = env2->GetIsolate()->GetHeapProfiler();

  CompileRun(

      "function A2() {}\n"

      "function B2(x) { return function() { return typeof x; }; }\n"

      "function C2(x) { this.x1 = x; this.x2 = x; this[1] = x; }\n"

      "var a2 = new A2();\n"

      "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"));

  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);

  const v8::HeapGraphNode* x1 =

      GetProperty(x, v8::HeapGraphEdge::kProperty, "a");

  CHECK_NE(NULL, x1);

  const v8::HeapGraphNode* x2 =

      GetProperty(x, v8::HeapGraphEdge::kProperty, "b");

  CHECK_NE(NULL, x2);

  // Test sizes.

  CHECK_NE(0, x->GetSelfSize());

  CHECK_NE(0, x1->GetSelfSize());

  CHECK_NE(0, x2->GetSelfSize());

}

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::New("native_bind"), f->GetName());

  const v8::HeapGraphNode* bindings =

      GetProperty(f, v8::HeapGraphEdge::kInternal, "bindings");

  CHECK_NE(NULL, bindings);

  CHECK_EQ(v8::HeapGraphNode::kArray, bindings->GetType());

  CHECK_EQ(4, 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");

  CHECK(bound_function);

  CHECK_EQ(v8::HeapGraphNode::kClosure, bound_function->GetType());

  const v8::HeapGraphNode* bound_argument = GetProperty(

      f, v8::HeapGraphEdge::kShortcut, "bound_argument_1");

  CHECK(bound_argument);

  CHECK_EQ(v8::HeapGraphNode::kObject, bound_argument->GetType());

}

TEST(HeapSnapshotEntryChildren) {

  LocalContext env;

  v8::HandleScope scope(env->GetIsolate());

  v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();

  CompileRun(

      "function A() { }\n"

      "a = new A;");

  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);

  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_EQ(v8::HeapGraphNode::kClosure, compiled->GetType());

  const v8::HeapGraphNode* lazy =

      GetProperty(global, v8::HeapGraphEdge::kProperty, "lazy");

  CHECK_NE(NULL, lazy);

  CHECK_EQ(v8::HeapGraphNode::kClosure, lazy->GetType());

  const v8::HeapGraphNode* anonymous =

      GetProperty(global, v8::HeapGraphEdge::kProperty, "anonymous");

  CHECK_NE(NULL, anonymous);

  CHECK_EQ(v8::HeapGraphNode::kClosure, anonymous->GetType());

  v8::String::Utf8Value anonymous_name(anonymous->GetName());

  CHECK_EQ("", *anonymous_name);

  // Find references to code.

  const v8::HeapGraphNode* compiled_code =

      GetProperty(compiled, v8::HeapGraphEdge::kInternal, "shared");

  CHECK_NE(NULL, compiled_code);

  const v8::HeapGraphNode* lazy_code =

      GetProperty(lazy, v8::HeapGraphEdge::kInternal, "shared");

  CHECK_NE(NULL, lazy_code);

  // 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")) {

        compiled_references_x = true;

        break;

      }

    }

  }

  for (int i = 0, count = lazy_code->GetChildrenCount(); i < count; ++i) {

    const v8::HeapGraphEdge* prop = lazy_code->GetChild(i);

    const v8::HeapGraphNode* node = prop->GetToNode();

    if (node->GetType() == v8::HeapGraphNode::kArray) {

      if (HasString(node, "x")) {

        lazy_references_x = true;

        break;

      }

    }

  }

  CHECK(compiled_references_x);

  CHECK(!lazy_references_x);

}

TEST(HeapSnapshotHeapNumbers) {

  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"));

  const v8::HeapGraphNode* b =

      GetProperty(global, v8::HeapGraphEdge::kProperty, "b");

  CHECK_NE(NULL, 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);

  const v8::HeapGraphNode* child_string =

      GetProperty(global, v8::HeapGraphEdge::kProperty, "child_string");

  CHECK_NE(NULL, 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();

  v8::HandleScope scope(isolate);

  v8::Local<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();

  global_template->SetInternalFieldCount(1);

  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(1, global->InternalFieldCount());

  i::Factory* factory = CcTest::i_isolate()->factory();

  i::Handle<i::String> first =

      factory->NewStringFromAscii(i::CStrVector("0123456789"));

  i::Handle<i::String> second =

      factory->NewStringFromAscii(i::CStrVector("0123456789"));

  i::Handle<i::String> cons_string = factory->NewConsString(first, second);

  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_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(HeapSnapshotInternalReferences) {

  v8::Isolate* isolate = CcTest::isolate();

  v8::HandleScope scope(isolate);

  v8::Local<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();

  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();

  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"));

  // The second reference is to an object.

  CHECK_NE(NULL, 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);

  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);

}

TEST(HeapEntryIdsAndArrayShift) {

  LocalContext env;

  v8::HandleScope scope(env->GetIsolate());

  v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();

  CompileRun(

      "function AnObject() {\n"

      "    this.first = 'first';\n"

      "    this.second = 'second';\n"

      "}\n"

      "var a = new Array();\n"

      "for (var i = 0; i < 10; ++i)\n"

      "  a.push(new AnObject());\n");

  const v8::HeapSnapshot* snapshot1 =

      heap_profiler->TakeHeapSnapshot(v8_str("s1"));

  CHECK(ValidateSnapshot(snapshot1));

  CompileRun(

      "for (var i = 0; i < 1; ++i)\n"

      "  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());

  const v8::HeapGraphNode* a1 =

      GetProperty(global1, v8::HeapGraphEdge::kProperty, "a");

  CHECK_NE(NULL, a1);

  const v8::HeapGraphNode* k1 =

      GetProperty(a1, v8::HeapGraphEdge::kInternal, "elements");

  CHECK_NE(NULL, k1);

  const v8::HeapGraphNode* a2 =

      GetProperty(global2, v8::HeapGraphEdge::kProperty, "a");

  CHECK_NE(NULL, a2);

  const v8::HeapGraphNode* k2 =

      GetProperty(a2, v8::HeapGraphEdge::kInternal, "elements");

  CHECK_NE(NULL, k2);

  CHECK_EQ_SNAPSHOT_OBJECT_ID(a1->GetId(), a2->GetId());

  CHECK_EQ_SNAPSHOT_OBJECT_ID(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(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());

  const v8::HeapGraphNode* A1 =

      GetProperty(global1, v8::HeapGraphEdge::kProperty, "A");

  CHECK_NE(NULL, 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());

  const v8::HeapGraphNode* B1 =

      GetProperty(global1, v8::HeapGraphEdge::kProperty, "B");

  CHECK_NE(NULL, 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());

  const v8::HeapGraphNode* a1 =

      GetProperty(global1, v8::HeapGraphEdge::kProperty, "a");

  CHECK_NE(NULL, 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());

  const v8::HeapGraphNode* b1 =

      GetProperty(global1, v8::HeapGraphEdge::kProperty, "b");

  CHECK_NE(NULL, 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());

}

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));

  const v8::HeapGraphNode* root1 = snapshot->GetRoot();

  const_cast<i::HeapSnapshot*>(reinterpret_cast<const i::HeapSnapshot*>(

      snapshot))->GetSortedEntriesList();

  const v8::HeapGraphNode* root2 = snapshot->GetRoot();

  CHECK_EQ(root1, root2);

}

namespace {

class TestJSONStream : public v8::OutputStream {

 public:

  TestJSONStream() : eos_signaled_(0), abort_countdown_(-1) {}

  explicit TestJSONStream(int abort_countdown)

      : eos_signaled_(0), abort_countdown_(abort_countdown) {}

  virtual ~TestJSONStream() {}

  virtual void EndOfStream() { ++eos_signaled_; }

  virtual WriteResult WriteAsciiChunk(char* buffer, int chars_written) {

    if (abort_countdown_ > 0) --abort_countdown_;

    if (abort_countdown_ == 0) return kAbort;

    CHECK_GT(chars_written, 0);

    i::Vector<char> chunk = buffer_.AddBlock(chars_written, '\0');

    i::OS::MemCopy(chunk.start(), buffer, chars_written);

    return kContinue;

  }

  virtual WriteResult WriteUint32Chunk(uint32_t* buffer, int chars_written) {

    ASSERT(false);

    return kAbort;

  }

  void WriteTo(i::Vector<char> dest) { buffer_.WriteTo(dest); }

  int eos_signaled() { return eos_signaled_; }

  int size() { return buffer_.size(); }

 private:

  i::Collector<char> buffer_;

  int eos_signaled_;

  int abort_countdown_;

};

class AsciiResource: public v8::String::ExternalAsciiStringResource {

 public:

  explicit AsciiResource(i::Vector<char> string): data_(string.start()) {

    length_ = string.length();

  }

  virtual const char* data() const { return data_; }

  virtual size_t length() const { return length_; }

 private:

  const char* data_;

  size_t length_;

};

}  // namespace

TEST(HeapSnapshotJSONSerialization) {

  LocalContext env;

  v8::HandleScope scope(env->GetIsolate());

  v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();

#define STRING_LITERAL_FOR_TEST \

  "\"String \\n\\r\\u0008\\u0081\\u0101\\u0801\\u8001\""

  CompileRun(

      "function A(s) { this.s = s; }\n"

      "function B(x) { this.x = x; }\n"

      "var a = new A(" STRING_LITERAL_FOR_TEST ");\n"

      "var b = new B(a);");

  const v8::HeapSnapshot* snapshot =

      heap_profiler->TakeHeapSnapshot(v8_str("json"));

  CHECK(ValidateSnapshot(snapshot));

  TestJSONStream stream;

  snapshot->Serialize(&stream, v8::HeapSnapshot::kJSON);

  CHECK_GT(stream.size(), 0);

  CHECK_EQ(1, stream.eos_signaled());

  i::ScopedVector<char> json(stream.size());

  stream.WriteTo(json);

  // Verify that snapshot string is valid JSON.

  AsciiResource json_res(json);

  v8::Local<v8::String> json_string = v8::String::NewExternal(&json_res);

  env->Global()->Set(v8_str("json_snapshot"), json_string);

  v8::Local<v8::Value> snapshot_parse_result = CompileRun(

      "var parsed = JSON.parse(json_snapshot); true;");

  CHECK(!snapshot_parse_result.IsEmpty());

  // Verify that snapshot object has required fields.

  v8::Local<v8::Object> parsed_snapshot =

      env->Global()->Get(v8_str("parsed"))->ToObject();

  CHECK(parsed_snapshot->Has(v8_str("snapshot")));

  CHECK(parsed_snapshot->Has(v8_str("nodes")));

  CHECK(parsed_snapshot->Has(v8_str("edges")));

  CHECK(parsed_snapshot->Has(v8_str("strings")));

  // Get node and edge "member" offsets.

  v8::Local<v8::Value> meta_analysis_result = CompileRun(

      "var meta = parsed.snapshot.meta;\n"

      "var edge_count_offset = meta.node_fields.indexOf('edge_count');\n"

      "var node_fields_count = meta.node_fields.length;\n"

      "var edge_fields_count = meta.edge_fields.length;\n"

      "var edge_type_offset = meta.edge_fields.indexOf('type');\n"

      "var edge_name_offset = meta.edge_fields.indexOf('name_or_index');\n"

      "var edge_to_node_offset = meta.edge_fields.indexOf('to_node');\n"

      "var property_type ="

      "    meta.edge_types[edge_type_offset].indexOf('property');\n"

      "var shortcut_type ="

      "    meta.edge_types[edge_type_offset].indexOf('shortcut');\n"

      "var node_count = parsed.nodes.length / node_fields_count;\n"

      "var first_edge_indexes = parsed.first_edge_indexes = [];\n"

      "for (var i = 0, first_edge_index = 0; i < node_count; ++i) {\n"

      "  first_edge_indexes[i] = first_edge_index;\n"

      "  first_edge_index += edge_fields_count *\n"

      "      parsed.nodes[i * node_fields_count + edge_count_offset];\n"

      "}\n"

      "first_edge_indexes[node_count] = first_edge_index;\n");

  CHECK(!meta_analysis_result.IsEmpty());

  // A helper function for processing encoded nodes.

  CompileRun(

      "function GetChildPosByProperty(pos, prop_name, prop_type) {\n"

      "  var nodes = parsed.nodes;\n"

      "  var edges = parsed.edges;\n"

      "  var strings = parsed.strings;\n"

      "  var node_ordinal = pos / node_fields_count;\n"

      "  for (var i = parsed.first_edge_indexes[node_ordinal],\n"

      "      count = parsed.first_edge_indexes[node_ordinal + 1];\n"

      "      i < count; i += edge_fields_count) {\n"

      "    if (edges[i + edge_type_offset] === prop_type\n"

      "        && strings[edges[i + edge_name_offset]] === prop_name)\n"

      "      return edges[i + edge_to_node_offset];\n"

      "  }\n"

      "  return null;\n"

      "}\n");

  // Get the string index using the path: <root> -> <global>.b.x.s

  v8::Local<v8::Value> string_obj_pos_val = CompileRun(

      "GetChildPosByProperty(\n"

      "  GetChildPosByProperty(\n"

      "    GetChildPosByProperty("

      "      parsed.edges[edge_fields_count + edge_to_node_offset],"

      "      \"b\", property_type),\n"

      "    \"x\", property_type),"

      "  \"s\", property_type)");

  CHECK(!string_obj_pos_val.IsEmpty());

  int string_obj_pos =

      static_cast<int>(string_obj_pos_val->ToNumber()->Value());

  v8::Local<v8::Object> nodes_array =

      parsed_snapshot->Get(v8_str("nodes"))->ToObject();

  int string_index = static_cast<int>(

      nodes_array->Get(string_obj_pos + 1)->ToNumber()->Value());

  CHECK_GT(string_index, 0);

  v8::Local<v8::Object> strings_array =

      parsed_snapshot->Get(v8_str("strings"))->ToObject();

  v8::Local<v8::String> string = strings_array->Get(string_index)->ToString();

  v8::Local<v8::String> ref_string =

      CompileRun(STRING_LITERAL_FOR_TEST)->ToString();

#undef STRING_LITERAL_FOR_TEST

  CHECK_EQ(*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));

  TestJSONStream stream(5);

  snapshot->Serialize(&stream, v8::HeapSnapshot::kJSON);

  CHECK_GT(stream.size(), 0);

  CHECK_EQ(0, stream.eos_signaled());

}

namespace {

class TestStatsStream : public v8::OutputStream {

 public:

  TestStatsStream()

    : eos_signaled_(0),

      updates_written_(0),

      entries_count_(0),

      entries_size_(0),

      intervals_count_(0),

      first_interval_index_(-1) { }

  TestStatsStream(const TestStatsStream& stream)

    : v8::OutputStream(stream),

      eos_signaled_(stream.eos_signaled_),

      updates_written_(stream.updates_written_),

      entries_count_(stream.entries_count_),

      entries_size_(stream.entries_size_),

      intervals_count_(stream.intervals_count_),

      first_interval_index_(stream.first_interval_index_) { }

  virtual ~TestStatsStream() {}

  virtual void EndOfStream() { ++eos_signaled_; }

  virtual WriteResult WriteAsciiChunk(char* buffer, int chars_written) {

    ASSERT(false);

    return kAbort;

  }

  virtual WriteResult WriteHeapStatsChunk(v8::HeapStatsUpdate* buffer,

                                          int updates_written) {

    ++intervals_count_;

    ASSERT(updates_written);

    updates_written_ += updates_written;

    entries_count_ = 0;

    if (first_interval_index_ == -1 && updates_written != 0)

      first_interval_index_ = buffer[0].index;

    for (int i = 0; i < updates_written; ++i) {

      entries_count_ += buffer[i].count;

      entries_size_ += buffer[i].size;

    }

    return kContinue;

  }

  int eos_signaled() { return eos_signaled_; }

  int updates_written() { return updates_written_; }

  uint32_t entries_count() const { return entries_count_; }

  uint32_t entries_size() const { return entries_size_; }

  int intervals_count() const { return intervals_count_; }

  int first_interval_index() const { return first_interval_index_; }

 private:

  int eos_signaled_;

  int updates_written_;

  uint32_t entries_count_;

  uint32_t entries_size_;

  int intervals_count_;

  int first_interval_index_;

};

}  // namespace

static TestStatsStream GetHeapStatsUpdate(

    v8::HeapProfiler* heap_profiler,

    v8::SnapshotObjectId* object_id = NULL) {

  TestStatsStream stream;

  v8::SnapshotObjectId last_seen_id = heap_profiler->GetHeapStats(&stream);

  if (object_id)

    *object_id = last_seen_id;

  CHECK_EQ(1, stream.eos_signaled());

  return stream;

}

TEST(HeapSnapshotObjectsStats) {

  LocalContext env;

  v8::HandleScope scope(env->GetIsolate());

  v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();

  heap_profiler->StartTrackingHeapObjects();

  // We have to call GC 6 times. In other case the garbage will be

  // the reason of flakiness.

  for (int i = 0; i < 6; ++i) {

    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_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);

  {

    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_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);

    {

      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_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());

        // 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());

      // 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());

    // 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();

  CHECK_EQ(0, 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());

    // They are the array and its buffer.

    CHECK_EQ(2, 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(8, stats_update.first_interval_index());

  }

  heap_profiler->StopTrackingHeapObjects();

}

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(), 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));

}

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::New("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());

}

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);

}

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) {

    done_ = done;

    total_ = total;

    return --abort_count_ != 0 ? kContinue : kAbort;

  }

  int done() { return done_; }

  int total() { return total_; }

 private:

  int done_;

  int total_;

  int abort_count_;

};

}

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_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_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:

  TestRetainedObjectInfo(int hash,

                         const char* group_label,

                         const char* label,

                         intptr_t element_count = -1,

                         intptr_t size = -1)

      : disposed_(false),

        hash_(hash),

        group_label_(group_label),

        label_(label),

        element_count_(element_count),

        size_(size) {

    instances.Add(this);

  }

  virtual ~TestRetainedObjectInfo() {}

  virtual void Dispose() {

    CHECK(!disposed_);

    disposed_ = true;

  }

  virtual bool IsEquivalent(RetainedObjectInfo* other) {

    return GetHash() == other->GetHash();

  }

  virtual intptr_t GetHash() { return hash_; }

  virtual const char* GetGroupLabel() { return group_label_; }

  virtual const char* GetLabel() { return label_; }

  virtual intptr_t GetElementCount() { return element_count_; }

  virtual intptr_t GetSizeInBytes() { return size_; }

  bool disposed() { return disposed_; }

  static v8::RetainedObjectInfo* WrapperInfoCallback(

      uint16_t class_id, v8::Handle<v8::Value> wrapper) {

    if (class_id == 1) {

      if (wrapper->IsString()) {

        v8::String::Utf8Value utf8(wrapper);

        if (strcmp(*utf8, "AAA") == 0)

          return new TestRetainedObjectInfo(1, "aaa-group", "aaa", 100);

        else if (strcmp(*utf8, "BBB") == 0)

          return new TestRetainedObjectInfo(1, "aaa-group", "aaa", 100);

      }

    } else if (class_id == 2) {

      if (wrapper->IsString()) {

        v8::String::Utf8Value utf8(wrapper);

        if (strcmp(*utf8, "CCC") == 0)

          return new TestRetainedObjectInfo(2, "ccc-group", "ccc");

      }

    }

    CHECK(false);

    return NULL;

  }

  static i::List<TestRetainedObjectInfo*> instances;

 private:

  bool disposed_;

  int hash_;

  const char* group_label_;

  const char* label_;

  intptr_t element_count_;

  intptr_t size_;

};

i::List<TestRetainedObjectInfo*> TestRetainedObjectInfo::instances;

}

static const v8::HeapGraphNode* GetNode(const v8::HeapGraphNode* parent,

                                        v8::HeapGraphNode::Type type,

                                        const char* name) {

  for (int i = 0, count = parent->GetChildrenCount(); i < count; ++i) {

    const v8::HeapGraphNode* node = parent->GetChild(i)->GetToNode();

    if (node->GetType() == type && strcmp(name,

               const_cast<i::HeapEntry*>(

                   reinterpret_cast<const i::HeapEntry*>(node))->name()) == 0) {

      return node;

    }

  }

  return NULL;

}

TEST(HeapSnapshotRetainedObjectInfo) {

  LocalContext env;

  v8::Isolate* isolate = env->GetIsolate();

  v8::HandleScope scope(isolate);

  v8::HeapProfiler* heap_profiler = isolate->GetHeapProfiler();

  heap_profiler->SetWrapperClassInfoProvider(

      1, TestRetainedObjectInfo::WrapperInfoCallback);

  heap_profiler->SetWrapperClassInfoProvider(

      2, TestRetainedObjectInfo::WrapperInfoCallback);

  v8::Persistent<v8::String> p_AAA(isolate, v8_str("AAA"));

  p_AAA.SetWrapperClassId(1);

  v8::Persistent<v8::String> p_BBB(isolate, v8_str("BBB"));

  p_BBB.SetWrapperClassId(1);

  v8::Persistent<v8::String> p_CCC(isolate, v8_str("CCC"));