EXPECT_EQ(size, ubi.size(fakeMallocSizeOf));
    EXPECT_EQ(typeName, ubi.typeName());
    EXPECT_EQ(id, ubi.identifier());
    EXPECT_FALSE(ubi.isLive());
    EXPECT_EQ(strcmp(ubi.jsObjectClassName(), className), 0);

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

    UniquePtr<DeserializedNode> referent1(new MockDeserializedNode(1,
                                                                   nullptr,
                                                                   10));
    DeserializedEdge edge1;
    edge1.referent = 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;
    edge2.referent = referent2->id;
    mocked.addEdge(Move(edge2));
    EXPECT_CALL(mocked,
                getEdgeReferent(Field(&DeserializedEdge::referent,
                                      referent2->id)))
      .Times(1)
      .WillOnce(Return(JS::ubi::Node(referent2.get())));
    FakeNode referent;

    const char16_t edgeName[] = MOZ_UTF16("edge name");
    const char16_t emptyStr[] = MOZ_UTF16("");

    AddEdge(node, referent, edgeName);
    AddEdge(node, referent, emptyStr);
    AddEdge(node, referent, nullptr);

    ::testing::NiceMock<MockWriter> writer;

    // Should get the node with edges once.
    EXPECT_CALL(
      writer,
      writeNode(AllOf(EdgesLength(rt, 3),
                      Edge(rt, 0, Field(&JS::ubi::Edge::name,
                                        UTF16StrEq(edgeName))),
                      Edge(rt, 1, Field(&JS::ubi::Edge::name,
                                        UTF16StrEq(emptyStr))),
                      Edge(rt, 2, Field(&JS::ubi::Edge::name,
                                        IsNull()))),
                _)
    )
      .Times(1)
      .WillOnce(Return(true));

    // Should get the referent node that doesn't have any edges once.
    ExpectWriteNode(writer, referent);

    JS::AutoCheckCannotGC noGC(rt);
    ASSERT_TRUE(WriteHeapGraph(cx,
                               JS::ubi::Node(&node),