palemoon27/toolkit/devtools/server/tests/gtest/DeserializedNodeUbiNodes.cpp

/* -*-  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(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 = MOZ_UTF16("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(Move(edge1));
    EXPECT_CALL(mocked,
                getEdgeReferent(Field(&DeserializedEdge::referent,
                                      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(Move(edge2));
    EXPECT_CALL(mocked,
                getEdgeReferent(Field(&DeserializedEdge::referent,
                                      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(Move(edge3));
    EXPECT_CALL(mocked,
                getEdgeReferent(Field(&DeserializedEdge::referent,
                                      referent3->id)))
      .Times(1)
      .WillOnce(Return(JS::ubi::Node(referent3.get())));

    auto range = ubi.edges(rt);
    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.
    }
  });