tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

DeserializedNodeUbiNodes.cpp (3181B)

      1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; -*- */
      2 /* This Source Code Form is subject to the terms of the Mozilla Public
      3 * License, v. 2.0. If a copy of the MPL was not distributed with this
      4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      5 
      6 // Test that the `JS::ubi::Node`s we create from
      7 // `mozilla::devtools::DeserializedNode` instances look and behave as we would
      8 // like.
      9 
     10 #include "DevTools.h"
     11 #include "js/TypeDecls.h"
     12 #include "mozilla/devtools/DeserializedNode.h"
     13 
     14 using testing::Field;
     15 using testing::ReturnRef;
     16 
     17 // A mock DeserializedNode for testing.
     18 struct MockDeserializedNode : public DeserializedNode {
     19  MockDeserializedNode(NodeId id, const char16_t* typeName, uint64_t size)
     20      : DeserializedNode(id, typeName, size) {}
     21 
     22  bool addEdge(DeserializedEdge&& edge) {
     23    return edges.append(std::move(edge));
     24  }
     25 
     26  MOCK_METHOD1(getEdgeReferent, JS::ubi::Node(const DeserializedEdge&));
     27 };
     28 
     29 size_t fakeMallocSizeOf(const void*) {
     30  EXPECT_TRUE(false);
     31  MOZ_ASSERT_UNREACHABLE(
     32      "fakeMallocSizeOf should never be called because "
     33      "DeserializedNodes report the deserialized size.");
     34  return 0;
     35 }
     36 
     37 DEF_TEST(DeserializedNodeUbiNodes, {
     38  const char16_t* typeName = u"TestTypeName";
     39  const char* className = "MyObjectClassName";
     40  const char* filename = "my-cool-filename.js";
     41 
     42  NodeId id = uint64_t(1) << 33;
     43  uint64_t size = uint64_t(1) << 60;
     44  MockDeserializedNode mocked(id, typeName, size);
     45  mocked.coarseType = JS::ubi::CoarseType::Script;
     46  mocked.jsObjectClassName = className;
     47  mocked.scriptFilename = filename;
     48 
     49  DeserializedNode& deserialized = mocked;
     50  JS::ubi::Node ubi(&deserialized);
     51 
     52  // Test the ubi::Node accessors.
     53 
     54  EXPECT_EQ(size, ubi.size(fakeMallocSizeOf));
     55  EXPECT_EQ(typeName, ubi.typeName());
     56  EXPECT_EQ(JS::ubi::CoarseType::Script, ubi.coarseType());
     57  EXPECT_EQ(id, ubi.identifier());
     58  EXPECT_FALSE(ubi.isLive());
     59  EXPECT_EQ(ubi.jsObjectClassName(), className);
     60  EXPECT_EQ(ubi.scriptFilename(), filename);
     61 
     62  // Test the ubi::Node's edges.
     63 
     64  UniquePtr<DeserializedNode> referent1(
     65      new MockDeserializedNode(1, nullptr, 10));
     66  DeserializedEdge edge1(referent1->id);
     67  mocked.addEdge(std::move(edge1));
     68  EXPECT_CALL(mocked, getEdgeReferent(EdgeTo(referent1->id)))
     69      .Times(1)
     70      .WillOnce(Return(JS::ubi::Node(referent1.get())));
     71 
     72  UniquePtr<DeserializedNode> referent2(
     73      new MockDeserializedNode(2, nullptr, 20));
     74  DeserializedEdge edge2(referent2->id);
     75  mocked.addEdge(std::move(edge2));
     76  EXPECT_CALL(mocked, getEdgeReferent(EdgeTo(referent2->id)))
     77      .Times(1)
     78      .WillOnce(Return(JS::ubi::Node(referent2.get())));
     79 
     80  UniquePtr<DeserializedNode> referent3(
     81      new MockDeserializedNode(3, nullptr, 30));
     82  DeserializedEdge edge3(referent3->id);
     83  mocked.addEdge(std::move(edge3));
     84  EXPECT_CALL(mocked, getEdgeReferent(EdgeTo(referent3->id)))
     85      .Times(1)
     86      .WillOnce(Return(JS::ubi::Node(referent3.get())));
     87 
     88  auto range = ubi.edges(cx);
     89  ASSERT_TRUE(!!range);
     90 
     91  for (; !range->empty(); range->popFront()) {
     92    // Nothing to do here. This loop ensures that we get each edge referent
     93    // that we expect above.
     94  }
     95 });