| // Copyright 2013 The Flutter Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "fakes/scenic/fake_session.h" |
| |
| #include <fuchsia/ui/scenic/cpp/fidl.h> |
| #include <fuchsia/ui/views/cpp/fidl.h> |
| #include <lib/async-testing/test_loop.h> |
| #include <lib/async/dispatcher.h> |
| #include <lib/ui/scenic/cpp/resources.h> |
| #include <lib/ui/scenic/cpp/session.h> |
| #include <lib/ui/scenic/cpp/view_ref_pair.h> |
| #include <lib/ui/scenic/cpp/view_token_pair.h> |
| #include <zircon/types.h> |
| |
| #include <memory> |
| #include <string> |
| #include <type_traits> |
| #include <vector> |
| |
| #include "flutter/fml/logging.h" |
| #include "gmock/gmock.h" // For EXPECT_THAT and matchers |
| #include "gtest/gtest.h" |
| |
| #include "fakes/scenic/fake_resources.h" |
| |
| using ::testing::_; |
| using ::testing::AllOf; |
| using ::testing::ElementsAre; |
| using ::testing::FieldsAre; |
| using ::testing::IsEmpty; |
| using ::testing::Matcher; |
| using ::testing::Not; |
| using ::testing::Pair; |
| using ::testing::Pointee; |
| using ::testing::SizeIs; |
| using ::testing::VariantWith; |
| |
| namespace flutter_runner::testing { |
| namespace { |
| |
| std::string GetCurrentTestName() { |
| return ::testing::UnitTest::GetInstance()->current_test_info()->name(); |
| } |
| |
| zx_koid_t GetKoid(zx_handle_t handle) { |
| if (handle == ZX_HANDLE_INVALID) { |
| return ZX_KOID_INVALID; |
| } |
| |
| zx_info_handle_basic_t info; |
| zx_status_t status = zx_object_get_info(handle, ZX_INFO_HANDLE_BASIC, &info, |
| sizeof(info), nullptr, nullptr); |
| return status == ZX_OK ? info.koid : ZX_KOID_INVALID; |
| } |
| |
| zx_koid_t GetPeerKoid(zx_handle_t handle) { |
| if (handle == ZX_HANDLE_INVALID) { |
| return ZX_KOID_INVALID; |
| } |
| |
| zx_info_handle_basic_t info; |
| zx_status_t status = zx_object_get_info(handle, ZX_INFO_HANDLE_BASIC, &info, |
| sizeof(info), nullptr, nullptr); |
| return status == ZX_OK ? info.related_koid : ZX_KOID_INVALID; |
| } |
| |
| Matcher<FakeResource> IsEntityNode( |
| Matcher<decltype(FakeResource::id)> id, |
| Matcher<decltype(FakeResource::label)> label, |
| Matcher<decltype(FakeNode::children)> children) { |
| return FieldsAre( |
| id, label, FakeResource::kDefaultEmptyEventMask, |
| VariantWith<FakeEntityNode>(FieldsAre( |
| FieldsAre(children, FakeNode::kDefaultZeroRotation, |
| FakeNode::kDefaultOneScale, |
| FakeNode::kDefaultZeroTranslation, |
| FakeNode::kDefaultZeroAnchor, FakeNode::kIsHitTestable, |
| FakeNode::kIsSemanticallyVisible), |
| IsEmpty()))); |
| } |
| |
| Matcher<FakeSceneGraph> IsEmptySceneGraph() { |
| return FieldsAre(IsEmpty(), IsEmpty(), IsEmpty(), kInvalidFakeResourceId); |
| } |
| |
| MATCHER_P2(IsEntityNodeSceneGraph, node_label, node_id, "") { |
| static_assert(std::is_same_v<FakeSceneGraph, std::decay_t<decltype(arg)>>); |
| static_assert( |
| std::is_constructible_v<std::string, std::decay_t<decltype(node_label)>>); |
| static_assert( |
| std::is_same_v<FakeResourceId, std::decay_t<decltype(node_id)>>); |
| |
| return ExplainMatchResult( |
| FieldsAre( |
| IsEmpty(), |
| AllOf(SizeIs(1u), |
| Contains(Pair(node_id, Pointee(IsEntityNode(node_id, node_label, |
| IsEmpty()))))), |
| _, kInvalidFakeResourceId), |
| arg, result_listener); |
| } |
| |
| MATCHER_P5(IsBasicSceneGraph, |
| view_label, |
| node_label, |
| view_holder_koid, |
| view_ref_control_koid, |
| view_ref_koid, |
| "") { |
| static_assert(std::is_same_v<FakeSceneGraph, std::decay_t<decltype(arg)>>); |
| static_assert( |
| std::is_constructible_v<std::string, std::decay_t<decltype(view_label)>>); |
| static_assert( |
| std::is_constructible_v<std::string, std::decay_t<decltype(node_label)>>); |
| static_assert( |
| std::is_same_v<zx_koid_t, std::decay_t<decltype(view_holder_koid)>>); |
| static_assert( |
| std::is_same_v<zx_koid_t, std::decay_t<decltype(view_ref_control_koid)>>); |
| static_assert( |
| std::is_same_v<zx_koid_t, std::decay_t<decltype(view_ref_koid)>>); |
| |
| return ExplainMatchResult( |
| FieldsAre( |
| IsEmpty(), |
| AllOf(SizeIs(2u), |
| Contains(Pair(arg.root_view_id, |
| Pointee(FieldsAre( |
| arg.root_view_id, "", |
| FakeResource::kDefaultEmptyEventMask, |
| VariantWith<FakeView>(FieldsAre( |
| view_holder_koid, view_ref_control_koid, |
| view_ref_koid, view_label, |
| ElementsAre(Pointee(IsEntityNode( |
| _, node_label, IsEmpty()))), |
| FakeView::kDebugBoundsDisbaled))))))), |
| _, AllOf(Not(kInvalidFakeResourceId), arg.root_view_id)), |
| arg, result_listener); |
| } |
| |
| } // namespace |
| |
| class FakeSessionTest : public ::testing::Test, |
| public fuchsia::ui::scenic::SessionListener { |
| protected: |
| FakeSessionTest() |
| : session_listener_(this), session_subloop_(loop_.StartNewLoop()) {} |
| ~FakeSessionTest() override = default; |
| |
| async::TestLoop& loop() { return loop_; } |
| |
| FakeSession& fake_session() { return fake_session_; } |
| |
| scenic::Session CreateSession() { |
| FML_CHECK(!fake_session_.is_bound()); |
| FML_CHECK(!session_listener_.is_bound()); |
| |
| auto [session, session_listener] = |
| fake_session_.Bind(session_subloop_->dispatcher()); |
| session_listener_.Bind(std::move(session_listener)); |
| |
| return scenic::Session(session.Bind()); |
| } |
| |
| private: |
| // |fuchsia::ui::scenic::SessionListener| |
| void OnScenicError(std::string error) override { FAIL(); } |
| |
| // |fuchsia::ui::scenic::SessionListener| |
| void OnScenicEvent(std::vector<fuchsia::ui::scenic::Event> events) override { |
| FAIL(); |
| } |
| |
| async::TestLoop loop_; // Must come before FIDL bindings. |
| |
| fuchsia::ui::scenic::SessionPtr session_ptr_; |
| fidl::Binding<fuchsia::ui::scenic::SessionListener> session_listener_; |
| |
| std::unique_ptr<async::LoopInterface> session_subloop_; |
| FakeSession fake_session_; |
| }; |
| |
| TEST_F(FakeSessionTest, Initialization) { |
| EXPECT_EQ(fake_session().debug_name(), ""); |
| EXPECT_EQ(fake_session().command_queue().size(), 0u); |
| EXPECT_THAT(fake_session().SceneGraph(), IsEmptySceneGraph()); |
| |
| // Pump the loop one time; the session should retain its initial state. |
| loop().RunUntilIdle(); |
| EXPECT_EQ(fake_session().debug_name(), ""); |
| EXPECT_EQ(fake_session().command_queue().size(), 0u); |
| EXPECT_THAT(fake_session().SceneGraph(), IsEmptySceneGraph()); |
| } |
| |
| TEST_F(FakeSessionTest, DebugLabel) { |
| scenic::Session session = CreateSession(); |
| |
| // Set the session's debug name. The `SetDebugName` hasn't been processed |
| // yet, so the session's view of the debug name is still empty. |
| const std::string kDebugLabel = GetCurrentTestName(); |
| session.SetDebugName(kDebugLabel); |
| session.Flush(); // Bypass local command caching. |
| EXPECT_EQ(fake_session().debug_name(), ""); |
| |
| // Pump the loop; the contents of the initial `SetDebugName` should be |
| // processed. |
| loop().RunUntilIdle(); |
| EXPECT_EQ(fake_session().debug_name(), kDebugLabel); |
| } |
| |
| TEST_F(FakeSessionTest, CommandQueueInvariants) { |
| scenic::Session session = CreateSession(); |
| |
| // The scene graph is initially empty. |
| EXPECT_THAT(fake_session().SceneGraph(), IsEmptySceneGraph()); |
| |
| // Create entity node for testing; no creation commands have been processed |
| // yet, so the session's view of the scene graph is empty. |
| std::optional<scenic::EntityNode> node(&session); |
| session.Flush(); // Bypass local command caching. |
| EXPECT_EQ(fake_session().command_queue().size(), 0u); |
| EXPECT_THAT(fake_session().SceneGraph(), IsEmptySceneGraph()); |
| |
| // Pump the loop; the initial creation command should be enqueued but still |
| // not processed yet, so the session's view of the scene graph is empty. |
| loop().RunUntilIdle(); |
| EXPECT_GT(fake_session().command_queue().size(), 0u); |
| EXPECT_THAT(fake_session().SceneGraph(), IsEmptySceneGraph()); |
| |
| // Present initial scene graph. The `Present` hasn't been processed yet, so |
| // the session's view of the scene graph is still empty. |
| session.Present2(0u, 0u, [](auto...) {}); |
| EXPECT_GT(fake_session().command_queue().size(), 0u); |
| EXPECT_THAT(fake_session().SceneGraph(), IsEmptySceneGraph()); |
| |
| // Pump the loop; the contents of the initial `Present` should be processed. |
| loop().RunUntilIdle(); |
| EXPECT_EQ(fake_session().command_queue().size(), 0u); |
| EXPECT_THAT(fake_session().SceneGraph(), |
| IsEntityNodeSceneGraph("", node->id())); |
| } |
| |
| TEST_F(FakeSessionTest, SimpleResourceLifecycle) { |
| scenic::Session session = CreateSession(); |
| |
| // The scene graph is initially empty. |
| EXPECT_THAT(fake_session().SceneGraph(), IsEmptySceneGraph()); |
| |
| // Present an initial entity node, pumping the loop to process commands. |
| std::optional<scenic::EntityNode> node(&session); |
| session.Present2(0u, 0u, [](auto...) {}); |
| loop().RunUntilIdle(); |
| EXPECT_THAT(fake_session().SceneGraph(), |
| IsEntityNodeSceneGraph("", node->id())); |
| |
| // Present a simple property update on the test entity node. |
| const std::string kNodeLabel = "EntityNode"; |
| node->SetLabel(kNodeLabel); |
| session.Present2(0u, 0u, [](auto...) {}); |
| loop().RunUntilIdle(); |
| EXPECT_THAT(fake_session().SceneGraph(), |
| IsEntityNodeSceneGraph(kNodeLabel, node->id())); |
| |
| // Present the destruction of the entity node. |
| node.reset(); |
| session.Present2(0u, 0u, [](auto...) {}); |
| loop().RunUntilIdle(); |
| EXPECT_THAT(fake_session().SceneGraph(), IsEmptySceneGraph()); |
| } |
| |
| TEST_F(FakeSessionTest, ResourceReferenceCounting) { |
| scenic::Session session = CreateSession(); |
| |
| // Present a chain of 4 entity nodes for testing. |
| std::array<std::optional<scenic::EntityNode>, 4> nodes{ |
| std::optional<scenic::EntityNode>(&session), |
| std::optional<scenic::EntityNode>(&session), |
| std::optional<scenic::EntityNode>(&session), |
| std::optional<scenic::EntityNode>(&session)}; |
| const std::string kNodeLabel = "EntityNode"; |
| for (size_t i = 0; i < 4; i++) { |
| nodes[i]->SetLabel(kNodeLabel + std::string(1, '0' + i)); |
| if (i < 3) { |
| nodes[i]->AddChild(*nodes[i + 1]); |
| } |
| } |
| session.Present2(0u, 0u, [](auto...) {}); |
| loop().RunUntilIdle(); |
| { |
| auto scene_graph = fake_session().SceneGraph(); |
| EXPECT_EQ(scene_graph.root_view_id, kInvalidFakeResourceId); |
| EXPECT_EQ(scene_graph.buffer_collection_map.size(), 0u); |
| EXPECT_EQ(scene_graph.resource_map.size(), 4u); |
| EXPECT_EQ(scene_graph.label_map.size(), 4u); |
| for (size_t i = 0; i < 4; i++) { |
| const std::string node_i_label = kNodeLabel + std::string(1, '0' + i); |
| ASSERT_EQ(scene_graph.resource_map.count(nodes[i]->id()), 1u); |
| ASSERT_EQ(scene_graph.label_map.count(node_i_label), 1u); |
| |
| const auto node_i = scene_graph.resource_map[nodes[i]->id()]; |
| const auto node_i_label_resources = scene_graph.label_map[node_i_label]; |
| EXPECT_EQ(node_i_label_resources.size(), 1u); |
| EXPECT_FALSE(node_i_label_resources[0].expired()); |
| EXPECT_EQ(node_i_label_resources[0].lock(), node_i); |
| } |
| |
| EXPECT_THAT( |
| scene_graph.resource_map[nodes[0]->id()], |
| Pointee(IsEntityNode( |
| nodes[0]->id(), kNodeLabel + std::string(1, '0'), |
| ElementsAre(Pointee(IsEntityNode( |
| nodes[1]->id(), kNodeLabel + std::string(1, '1'), |
| ElementsAre(Pointee(IsEntityNode( |
| nodes[2]->id(), kNodeLabel + std::string(1, '2'), |
| ElementsAre(Pointee(IsEntityNode( |
| nodes[3]->id(), kNodeLabel + std::string(1, '3'), |
| IsEmpty())))))))))))); |
| } |
| |
| // Destroy node #0. It should be dropped immediately since it has no parent. |
| nodes[0].reset(); |
| session.Present2(0u, 0u, [](auto...) {}); |
| loop().RunUntilIdle(); |
| { |
| auto scene_graph = fake_session().SceneGraph(); |
| EXPECT_EQ(scene_graph.root_view_id, kInvalidFakeResourceId); |
| EXPECT_EQ(scene_graph.buffer_collection_map.size(), 0u); |
| EXPECT_EQ(scene_graph.resource_map.size(), 3u); |
| EXPECT_EQ(scene_graph.label_map.size(), 3u); |
| for (size_t i = 1; i < 4; i++) { |
| const std::string node_i_label = kNodeLabel + std::string(1, '0' + i); |
| ASSERT_EQ(scene_graph.resource_map.count(nodes[i]->id()), 1u); |
| ASSERT_EQ(scene_graph.label_map.count(node_i_label), 1u); |
| |
| const auto node_i = scene_graph.resource_map[nodes[i]->id()]; |
| const auto node_i_label_resources = scene_graph.label_map[node_i_label]; |
| EXPECT_EQ(node_i_label_resources.size(), 1u); |
| EXPECT_FALSE(node_i_label_resources[0].expired()); |
| EXPECT_EQ(node_i_label_resources[0].lock(), node_i); |
| } |
| |
| EXPECT_EQ(scene_graph.resource_map.count(nodes[0]->id()), 0u); |
| EXPECT_THAT(scene_graph.resource_map[nodes[1]->id()], |
| Pointee(IsEntityNode( |
| nodes[1]->id(), kNodeLabel + std::string(1, '1'), |
| ElementsAre(Pointee(IsEntityNode( |
| nodes[2]->id(), kNodeLabel + std::string(1, '2'), |
| ElementsAre(Pointee(IsEntityNode( |
| nodes[3]->id(), kNodeLabel + std::string(1, '3'), |
| IsEmpty()))))))))); |
| } |
| |
| // Destroy node #2. It should still exist in the tree and the labels map |
| // because it has a parent, but it is removed from the resource map. |
| nodes[2].reset(); |
| session.Present2(0u, 0u, [](auto...) {}); |
| loop().RunUntilIdle(); |
| { |
| auto scene_graph = fake_session().SceneGraph(); |
| EXPECT_EQ(scene_graph.root_view_id, kInvalidFakeResourceId); |
| EXPECT_EQ(scene_graph.buffer_collection_map.size(), 0u); |
| EXPECT_EQ(scene_graph.resource_map.size(), 2u); |
| EXPECT_EQ(scene_graph.label_map.size(), 3u); |
| for (size_t i = 1; i < 4; i++) { |
| const std::string node_i_label = kNodeLabel + std::string(1, '0' + i); |
| ASSERT_EQ(scene_graph.label_map.count(node_i_label), 1u); |
| ASSERT_EQ(scene_graph.resource_map.count(nodes[i]->id()), |
| i != 2 ? 1u : 0u); |
| |
| const auto node_i_label_resources = scene_graph.label_map[node_i_label]; |
| EXPECT_EQ(node_i_label_resources.size(), 1u); |
| EXPECT_FALSE(node_i_label_resources[0].expired()); |
| |
| if (i != 2) { |
| const auto node_i = scene_graph.resource_map[nodes[i]->id()]; |
| EXPECT_EQ(node_i_label_resources[0].lock(), node_i); |
| } else { |
| EXPECT_EQ(scene_graph.resource_map.count(nodes[i]->id()), 0u); |
| } |
| } |
| |
| EXPECT_THAT(scene_graph.resource_map[nodes[1]->id()], |
| Pointee(IsEntityNode( |
| nodes[1]->id(), kNodeLabel + std::string(1, '1'), |
| ElementsAre(Pointee(IsEntityNode( |
| nodes[2]->id(), kNodeLabel + std::string(1, '2'), |
| ElementsAre(Pointee(IsEntityNode( |
| nodes[3]->id(), kNodeLabel + std::string(1, '3'), |
| IsEmpty()))))))))); |
| } |
| |
| // Destroy node #3. It should still exist in the tree and the labels map |
| // because it has a grand-parent, but it is removed from the resource map. |
| nodes[3].reset(); |
| session.Present2(0u, 0u, [](auto...) {}); |
| loop().RunUntilIdle(); |
| { |
| auto scene_graph = fake_session().SceneGraph(); |
| EXPECT_EQ(scene_graph.root_view_id, kInvalidFakeResourceId); |
| EXPECT_EQ(scene_graph.buffer_collection_map.size(), 0u); |
| EXPECT_EQ(scene_graph.resource_map.size(), 1u); |
| EXPECT_EQ(scene_graph.label_map.size(), 3u); |
| for (size_t i = 1; i < 4; i++) { |
| const std::string node_i_label = kNodeLabel + std::string(1, '0' + i); |
| ASSERT_EQ(scene_graph.label_map.count(node_i_label), 1u); |
| ASSERT_EQ(scene_graph.resource_map.count(nodes[i]->id()), |
| i < 2 ? 1u : 0u); |
| |
| const auto node_i_label_resources = scene_graph.label_map[node_i_label]; |
| EXPECT_EQ(node_i_label_resources.size(), 1u); |
| EXPECT_FALSE(node_i_label_resources[0].expired()); |
| |
| if (i < 2) { |
| const auto node_i = scene_graph.resource_map[nodes[i]->id()]; |
| EXPECT_EQ(node_i_label_resources[0].lock(), node_i); |
| } else { |
| EXPECT_EQ(scene_graph.resource_map.count(nodes[i]->id()), 0u); |
| } |
| } |
| |
| EXPECT_THAT(scene_graph.resource_map[nodes[1]->id()], |
| Pointee(IsEntityNode( |
| nodes[1]->id(), kNodeLabel + std::string(1, '1'), |
| ElementsAre(Pointee(IsEntityNode( |
| nodes[2]->id(), kNodeLabel + std::string(1, '2'), |
| ElementsAre(Pointee(IsEntityNode( |
| nodes[3]->id(), kNodeLabel + std::string(1, '3'), |
| IsEmpty()))))))))); |
| } |
| } |
| |
| TEST_F(FakeSessionTest, BasicSceneGraph) { |
| scenic::Session session = CreateSession(); |
| |
| // The scene graph is initially empty. |
| EXPECT_THAT(fake_session().SceneGraph(), IsEmptySceneGraph()); |
| |
| // Create and present initial scene graph. |
| const std::string kViewDebugString = GetCurrentTestName(); |
| const std::string kNodeLabel = "ChildNode"; |
| fuchsia::ui::views::ViewRef view_ref; |
| auto [view_token, view_holder_token] = scenic::ViewTokenPair::New(); |
| auto view_ref_pair = scenic::ViewRefPair::New(); |
| view_ref_pair.view_ref.Clone(&view_ref); |
| scenic::View root_view(&session, std::move(view_token), |
| std::move(view_ref_pair.control_ref), |
| std::move(view_ref_pair.view_ref), kViewDebugString); |
| scenic::EntityNode child_node(&session); |
| child_node.SetLabel(kNodeLabel); |
| root_view.AddChild(child_node); |
| session.Present2(0u, 0u, [](auto...) {}); |
| loop().RunUntilIdle(); |
| EXPECT_THAT(fake_session().SceneGraph(), |
| IsBasicSceneGraph(kViewDebugString, kNodeLabel, |
| GetPeerKoid(view_holder_token.value.get()), |
| GetPeerKoid(view_ref.reference.get()), |
| GetKoid(view_ref.reference.get()))); |
| } |
| |
| } // namespace flutter_runner::testing |
