DeserializedNodeUbiNodes.cpp

Enable keyboard shortcuts

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; -*- */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

// Test that the `JS::ubi::Node`s we create from

// `mozilla::devtools::DeserializedNode` instances look and behave as we would

// like.

#include "DevTools.h"

#include "js/TypeDecls.h"

#include "mozilla/devtools/DeserializedNode.h"

using testing::Field;

using testing::ReturnRef;

// A mock DeserializedNode for testing.

struct MockDeserializedNode : public DeserializedNode {

  MockDeserializedNode(NodeId id, const char16_t* typeName, uint64_t size)

      : DeserializedNode(id, typeName, size) {}

  bool addEdge(DeserializedEdge&& edge) {

    return edges.append(std::move(edge));

  MOCK_METHOD1(getEdgeReferent, JS::ubi::Node(const DeserializedEdge&));

};

size_t fakeMallocSizeOf(const void*) {

  EXPECT_TRUE(false);

  MOZ_ASSERT_UNREACHABLE(

      "fakeMallocSizeOf should never be called because "

      "DeserializedNodes report the deserialized size.");

  return 0;

DEF_TEST(DeserializedNodeUbiNodes, {

  const char16_t* typeName = u"TestTypeName";

  const char* className = "MyObjectClassName";

  const char* filename = "my-cool-filename.js";

  NodeId id = uint64_t(1) << 33;

  uint64_t size = uint64_t(1) << 60;

  MockDeserializedNode mocked(id, typeName, size);

  mocked.coarseType = JS::ubi::CoarseType::Script;

  mocked.jsObjectClassName = className;

  mocked.scriptFilename = filename;

  DeserializedNode& deserialized = mocked;

  JS::ubi::Node ubi(&deserialized);

  // Test the ubi::Node accessors.

  EXPECT_EQ(size, ubi.size(fakeMallocSizeOf));

  EXPECT_EQ(typeName, ubi.typeName());

  EXPECT_EQ(JS::ubi::CoarseType::Script, ubi.coarseType());

  EXPECT_EQ(id, ubi.identifier());

  EXPECT_FALSE(ubi.isLive());

  EXPECT_EQ(ubi.jsObjectClassName(), className);

  EXPECT_EQ(ubi.scriptFilename(), filename);

  // Test the ubi::Node's edges.

  UniquePtr<DeserializedNode> referent1(

      new MockDeserializedNode(1, nullptr, 10));

  DeserializedEdge edge1(referent1->id);

  mocked.addEdge(std::move(edge1));

  EXPECT_CALL(mocked, getEdgeReferent(EdgeTo(referent1->id)))

      .Times(1)

      .WillOnce(Return(JS::ubi::Node(referent1.get())));

  UniquePtr<DeserializedNode> referent2(

      new MockDeserializedNode(2, nullptr, 20));

  DeserializedEdge edge2(referent2->id);

  mocked.addEdge(std::move(edge2));

  EXPECT_CALL(mocked, getEdgeReferent(EdgeTo(referent2->id)))

      .Times(1)

      .WillOnce(Return(JS::ubi::Node(referent2.get())));

  UniquePtr<DeserializedNode> referent3(

      new MockDeserializedNode(3, nullptr, 30));

  DeserializedEdge edge3(referent3->id);

  mocked.addEdge(std::move(edge3));

  EXPECT_CALL(mocked, getEdgeReferent(EdgeTo(referent3->id)))

      .Times(1)

      .WillOnce(Return(JS::ubi::Node(referent3.get())));

  auto range = ubi.edges(cx);

  ASSERT_TRUE(!!range);

  for (; !range->empty(); range->popFront()) {

    // Nothing to do here. This loop ensures that we get each edge referent

    // that we expect above.

});