sdk/lib/fidl/cpp/tests/integration/binding_group_test.cc

// Copyright 2022 The Fuchsia 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 <fidl/fidl.cpp.wire.bindinggroup.test/cpp/fidl.h>
#include <lib/async-loop/cpp/loop.h>
#include <lib/async/cpp/task.h>
#include <lib/fidl/cpp/wire/server.h>
#include <zircon/fidl.h>
#include <zircon/syscalls.h>

#include <thread>
#include <vector>

#include <zxtest/zxtest.h>

namespace {

using ::fidl_cpp_wire_bindinggroup_test::Testable;
constexpr zx_status_t kTestEpitaph = 1234;
constexpr char kSimpleEcho[] = "test";

// These are the default values for the number of impls and number of bindings per impl when
// testing. Some test running functions may use template parameters to override these as needed.
const size_t kTestNumImpls = 2;
const size_t kTestNumBindingsPerImpl = 2;

struct TestImpl : fidl::Server<Testable> {
 public:
  explicit TestImpl(async::Loop* loop) : loop(loop) {}

  void Echo(EchoRequest& request, EchoCompleter::Sync& completer) override {
    echo_count_++;
    completer.Reply(request.str());
  }

  // Always abruptly close the connection. This is not a good implementation to copy - its just
  // useful to check that close handling works properly.
  void Terminate(TerminateCompleter::Sync& completer) override {
    terminate_count_++;
    completer.Close(kTestEpitaph);
  }

  // Fired whenever the binding is closed via a |Close*| call on its parent |ServerBindingGroup|.
  void close_handler_fired() { close_count_++; }

  size_t get_echo_count() const { return echo_count_; }

  size_t get_close_count() const { return close_count_; }

  size_t get_terminate_count() const { return terminate_count_; }

  async::Loop* loop = nullptr;

 private:
  size_t close_count_ = 0;
  size_t echo_count_ = 0;
  size_t terminate_count_ = 0;
};

constexpr auto kCloseHandler = [](TestImpl* impl, fidl::UnbindInfo info) {
  impl->close_handler_fired();
  EXPECT_TRUE(info.did_send_epitaph());
  EXPECT_EQ(fidl::Reason::kClose, info.reason());
  EXPECT_OK(info.status());
};

TEST(BindingGroup, Trivial) { fidl::ServerBindingGroup<Testable> group; }

// Tests simple patterns for adding various numbers of bindings for various numbers of
// implementations. Additionally, this test template tests that the |size| and |ForEachBinding|
// methods work as expected.
template <size_t NumImpls = kTestNumImpls, size_t NumBindingsPerImpl = kTestNumBindingsPerImpl>
void AddBindingTest() {
  constexpr size_t TotalServerBindings = NumImpls * NumBindingsPerImpl;
  async::Loop loop(&kAsyncLoopConfigNeverAttachToThread);

  // Because we're going to be using raw pointers into these vectors for the test, its important to
  // pre-allocate, so that the underlying storage doesn't move.
  std::vector<TestImpl> impls;
  std::vector<fidl::WireClient<Testable>> clients;
  impls.reserve(NumImpls);
  clients.reserve(TotalServerBindings);

  // Data we are tracking for the duration of the test which we will assert against.
  std::map<const TestImpl*, size_t> unvisited_bindings_per_impl;

  fidl::ServerBindingGroup<Testable> group;

  // Create the right number of bindings for each impl as requested. Hold on to the client so that
  // we may poke at it later.
  for (size_t i = 0; i < NumImpls; i++) {
    impls.emplace_back(&loop);
    for (size_t j = i * NumBindingsPerImpl; j < (i + 1) * NumBindingsPerImpl; j++) {
      auto endpoints = fidl::Endpoints<Testable>::Create();
      group.AddBinding(loop.dispatcher(), std::move(endpoints.server), &impls.back(),
                       kCloseHandler);
      clients.emplace_back(std::move(endpoints.client), loop.dispatcher());
    }
    unvisited_bindings_per_impl.insert({&impls.back(), NumBindingsPerImpl});
  }
  EXPECT_EQ(group.size(), TotalServerBindings);
  EXPECT_EQ(clients.size(), TotalServerBindings);
  EXPECT_EQ(unvisited_bindings_per_impl.size(), NumImpls);

  // Make an |Echo| call on each |client| to ensure that its binding is actually responsive.
  for (auto& client : clients) {
    client->Echo(kSimpleEcho).ThenExactlyOnce([&](fidl::WireUnownedResult<Testable::Echo>& result) {
      ASSERT_TRUE(result.ok());
      EXPECT_OK(result.status());
      EXPECT_EQ(result.value().str.get(), kSimpleEcho);
    });

    // Run the loop until the callback is resolved.
    loop.RunUntilIdle();
  }

  // Ensure that each |impl| was called the number of times that we expect.
  for (const auto& impl : impls) {
    EXPECT_EQ(impl.get_echo_count(), NumBindingsPerImpl);
  }

  // Visit each binding, matching its implementation to one of the ones we're storing in the |impls|
  // array. Decrement the count in that array on each visit.
  size_t bindings_visited = 0;
  group.ForEachBinding([&](const fidl::ServerBinding<Testable>& binding) {
    bool matched = false;
    bindings_visited++;
    binding.AsImpl<TestImpl>([&](const TestImpl* binding_impl) {
      auto matched_impl = unvisited_bindings_per_impl.find(binding_impl);
      EXPECT_NE(matched_impl, unvisited_bindings_per_impl.end());
      matched = true;
      matched_impl->second--;
    });

    EXPECT_TRUE(matched);
  });

  // Because the previous loop decremented the count for each impl visited, we can iterate over the
  // |unvisited_bindings_per_impl| counters to ensure that they are all zero, confirming that every
  // |impl| has been visited the appropriate number of times.
  EXPECT_EQ(bindings_visited, TotalServerBindings);
  for (const auto& impl : unvisited_bindings_per_impl) {
    EXPECT_EQ(impl.second, 0);
  }
}

TEST(BindingGroup, AddBindingOneImplWithOneBinding) { AddBindingTest<1, 1>(); }

TEST(BindingGroup, AddBindingOneImplWithManyBindings) { AddBindingTest<1, 2>(); }

TEST(BindingGroup, AddBindingManyImplsWithOneBindingEach) { AddBindingTest<2, 1>(); }

TEST(BindingGroup, AddBindingManyImplsWithManyBindingsEach) { AddBindingTest<2, 2>(); }

// Tests adding bindings using the generator produced by the |CreateHandler| method.
template <size_t NumImpls = kTestNumImpls, size_t NumBindingsPerImpl = kTestNumBindingsPerImpl>
void CreateHandlerTest() {
  constexpr size_t TotalServerBindings = NumImpls * NumBindingsPerImpl;
  async::Loop loop(&kAsyncLoopConfigNeverAttachToThread);

  // Because we're going to be using raw pointers into these vectors for the test, its important to
  // pre-allocate, so that the underlying storage doesn't move.
  std::vector<TestImpl> impls;
  std::vector<fidl::WireClient<Testable>> clients;
  impls.reserve(NumImpls);
  clients.reserve(TotalServerBindings);

  fidl::ServerBindingGroup<Testable> group;

  // Create the right number of bindings for each impl as requested. Hold on to the client so that
  // we may poke at it later.
  for (size_t i = 0; i < NumImpls; i++) {
    impls.emplace_back(&loop);
    auto handler = group.CreateHandler(&impls.back(), loop.dispatcher(), kCloseHandler);
    for (size_t j = i * NumBindingsPerImpl; j < (i + 1) * NumBindingsPerImpl; j++) {
      auto endpoints = fidl::Endpoints<Testable>::Create();
      handler(std::move(endpoints.server));
      clients.emplace_back(std::move(endpoints.client), loop.dispatcher());
    }
  }
  EXPECT_EQ(group.size(), TotalServerBindings);
  EXPECT_EQ(clients.size(), TotalServerBindings);

  // Make an |Echo| call on each |client| to ensure that its binding is actually responsive.
  for (auto& client : clients) {
    client->Echo(kSimpleEcho).ThenExactlyOnce([&](fidl::WireUnownedResult<Testable::Echo>& result) {
      ASSERT_TRUE(result.ok());
      EXPECT_OK(result.status());
      EXPECT_EQ(result.value().str.get(), kSimpleEcho);
    });

    // Run the loop until the callback is resolved.
    loop.RunUntilIdle();
  }

  // Ensure that each |impl| was called the number of times that we expect.
  for (const auto& impl : impls) {
    EXPECT_EQ(impl.get_echo_count(), NumBindingsPerImpl);
  }
}

TEST(BindingGroup, CreateHandlerOneImplWithOneBinding) { CreateHandlerTest<1, 1>(); }

TEST(BindingGroup, CreateHandlerOneImplWithManyBindings) { CreateHandlerTest<1, 2>(); }

TEST(BindingGroup, CreateHandlerManyImplsWithOneBindingEach) { CreateHandlerTest<2, 1>(); }

TEST(BindingGroup, CreateHandlerManyImplsWithManyBindingsEach) { CreateHandlerTest<2, 2>(); }

// Tests that |CloseHandler| functions are correctly passed to, and fired by, bindings in the group.
template <size_t NumImpls = kTestNumImpls, size_t NumBindingsPerImpl = kTestNumBindingsPerImpl>
void CloseHandlerTest() {
  constexpr size_t TotalServerBindings = NumImpls * NumBindingsPerImpl;
  async::Loop loop(&kAsyncLoopConfigNeverAttachToThread);

  // Because we're going to be using raw pointers into these vectors for the test, its important to
  // pre-allocate, so that the underlying storage doesn't move.
  std::vector<TestImpl> impls;
  std::vector<fidl::WireClient<Testable>> clients;
  impls.reserve(NumImpls);
  clients.reserve(TotalServerBindings);

  // Data we are tracking for the duration of the test which we will assert against.
  size_t empty_set_handler_call_count = 0;

  fidl::ServerBindingGroup<Testable> group;

  // Add an |empty_handler| lambda to the |group|, and ensure that it only gets called once.
  group.set_empty_set_handler([&]() { empty_set_handler_call_count++; });

  // Create the right number of bindings for each impl as requested. Hold on to the client so that
  // we may poke at it later.
  for (size_t i = 0; i < NumImpls; i++) {
    impls.emplace_back(&loop);
    for (size_t j = i * NumBindingsPerImpl; j < (i + 1) * NumBindingsPerImpl; j++) {
      auto endpoints = fidl::Endpoints<Testable>::Create();
      group.AddBinding(loop.dispatcher(), std::move(endpoints.server), &impls.back(),
                       kCloseHandler);
      clients.emplace_back(std::move(endpoints.client), loop.dispatcher());
    }
  }
  EXPECT_EQ(group.size(), TotalServerBindings);
  EXPECT_EQ(clients.size(), TotalServerBindings);

  // Make a |Terminate| call on each |client| to ensure that it is abruptly torn down.
  for (auto& client : clients) {
    EXPECT_EQ(empty_set_handler_call_count, 0);

    auto result = client->Terminate();
    EXPECT_TRUE(result.ok());

    // Run the loop until the close handlers are resolved.
    loop.RunUntilIdle();
  }

  // Ensure that each |impl| was closed the number of times that we expect. In this case, that means
  // that every closure came from a |Terminate| method call on the client, and that every binding
  // was closed in this manner.
  for (const auto& impl : impls) {
    EXPECT_EQ(impl.get_terminate_count(), impl.get_close_count());
    EXPECT_EQ(impl.get_terminate_count(), NumBindingsPerImpl);
  }

  // Ensure that empty handler was only called once, after the last binding resolved its |Terminate|
  // handler.
  EXPECT_EQ(empty_set_handler_call_count, 1);
}

TEST(BindingGroup, CloseHandlerOneImplWithOneBinding) { CloseHandlerTest<1, 1>(); }

TEST(BindingGroup, CloseHandlerOneImplWithManyBindings) { CloseHandlerTest<1, 2>(); }

TEST(BindingGroup, CloseHandlerManyImplsWithOneBindingEach) { CloseHandlerTest<2, 1>(); }

TEST(BindingGroup, CloseHandlerManyImplsWithManyBindingsEach) { CloseHandlerTest<2, 2>(); }

using KillSomeBindings = fit::function<void(fidl::ServerBindingGroup<Testable>& group,
                                            async::Loop* loop, std::vector<TestImpl>& impls,
                                            std::map<size_t, const TestImpl*>& open_bindings)>;

// Tests that calling methods in the |Close*()| and |Remove*()| families works as expected. The
// |KillSomeBindings| lambda is used to |Remove*| or |Close*| some number of bindings as the
// specific test requires.
void ExternalKillBindingTest(KillSomeBindings kill_some_bindings) {
  constexpr size_t TotalServerBindings = kTestNumImpls * kTestNumBindingsPerImpl;
  async::Loop loop(&kAsyncLoopConfigNeverAttachToThread);

  class EventHandler : public fidl::WireAsyncEventHandler<Testable> {
   public:
    void on_fidl_error(fidl::UnbindInfo info) override {
      ASSERT_TRUE(info.is_peer_closed());
      closed_ = true;
    }

    bool closed() const { return closed_; }

   private:
    bool closed_ = false;
  };

  // Because we're going to be using raw pointers into these vectors for the test, its important to
  // pre-allocate, so that the underlying storage doesn't move.
  std::vector<TestImpl> impls;
  std::vector<fidl::WireClient<Testable>> clients;
  std::vector<EventHandler> event_handlers;
  impls.reserve(kTestNumImpls);
  clients.reserve(TotalServerBindings);
  event_handlers.reserve(TotalServerBindings);

  // Data we are tracking for the duration of the test which we will assert against.  The
  // |kill_some_bindings| handler should replace all entries in |open_bindings| with |nullptr| when
  // killing them.
  std::map<size_t, const TestImpl*> open_bindings;
  size_t empty_set_handler_call_count = 0;

  // Create the |group| under test, and define a counter-decrementing |close_handler| to attach to
  // each binding it holds.
  fidl::ServerBindingGroup<Testable> group;

  // Add an |empty_handler| lambda to the |group|, incrementing a simple counter each time it gets
  // called.
  group.set_empty_set_handler([&]() { empty_set_handler_call_count++; });

  // Create the right number of bindings for each impl as requested. Hold on to the client so that
  // we may poke at it later.
  for (size_t i = 0; i < kTestNumImpls; i++) {
    impls.emplace_back(&loop);
    for (size_t j = i * kTestNumBindingsPerImpl; j < (i + 1) * kTestNumBindingsPerImpl; j++) {
      auto endpoints = fidl::Endpoints<Testable>::Create();

      group.AddBinding(loop.dispatcher(), std::move(endpoints.server), &impls.back(),
                       kCloseHandler);
      event_handlers.emplace_back();
      clients.emplace_back(std::move(endpoints.client), loop.dispatcher(), &event_handlers.back());
      open_bindings.insert({j, &impls.back()});
    }
  }
  EXPECT_EQ(group.size(), TotalServerBindings);
  EXPECT_EQ(clients.size(), TotalServerBindings);

  // Call the |kill_some_bindings| lambda to kill the servers that the test requires.
  kill_some_bindings(group, &loop, impls, open_bindings);
  loop.RunUntilIdle();

  // Make a |Terminate| call on each remaining |client| to ensure that it is abruptly torn down.
  for (const auto& open_binding : open_bindings) {
    // If a |open_binding| is set to |nullptr|, that means the test body
    // explicitly removed/closed the binding, and we verify this has happened.
    // Otherwise, call |Terminate| to tell the server to close it.
    if (open_binding.second != nullptr) {
      EXPECT_FALSE(event_handlers[open_binding.first].closed());
      auto result = clients[open_binding.first]->Terminate();
      EXPECT_OK(result.status());
    } else {
      EXPECT_TRUE(event_handlers[open_binding.first].closed());
    }

    // Run the loop until the close handlers are resolved.
    loop.RunUntilIdle();
  }

  // All connections should now be closed.
  for (const auto& open_binding : open_bindings) {
    EXPECT_TRUE(event_handlers[open_binding.first].closed());
  }

  // Ensure that empty handler was only called once, after the last binding resolved its |Terminate|
  // handler.
  EXPECT_EQ(empty_set_handler_call_count, 1);
}

TEST(BindingGroup, RemoveBindings) {
  ExternalKillBindingTest([](fidl::ServerBindingGroup<Testable>& group, async::Loop* loop,
                             std::vector<TestImpl>& impls,
                             std::map<size_t, const TestImpl*>& open_bindings) {
    const TestImpl* target_impl = &impls[0];
    EXPECT_EQ(group.RemoveBindings(target_impl), true);
    EXPECT_EQ(group.RemoveBindings(target_impl), false);
    EXPECT_EQ(group.size(), 2);

    loop->RunUntilIdle();

    // Ensure that no close counters were incremented, since this was merely a removal.
    for (auto& impl : open_bindings) {
      EXPECT_EQ(impl.second->get_close_count(), 0);
    }

    // Mark the removed bindings as killed, so that the rest of the test knows which bindings
    // should and should not be closed via the client making a |Terminate| call.
    for (const auto& open_binding : open_bindings) {
      if (open_binding.second == target_impl) {
        open_bindings[open_binding.first] = nullptr;
      }
    }
  });
}

TEST(BindingGroup, RemoveAll) {
  ExternalKillBindingTest([](fidl::ServerBindingGroup<Testable>& group, async::Loop* loop,
                             std::vector<TestImpl>& impls,
                             std::map<size_t, const TestImpl*>& open_bindings) {
    EXPECT_EQ(group.RemoveAll(), true);
    EXPECT_EQ(group.RemoveAll(), false);
    EXPECT_EQ(group.size(), 0);

    loop->RunUntilIdle();

    // Ensure that no close counters were incremented, since this was merely a removal.
    for (auto& impl : open_bindings) {
      EXPECT_EQ(impl.second->get_close_count(), 0);
    }

    // Mark the removed bindings as killed, so that the rest of the test knows which bindings
    // should and should not be closed via the client making a |Terminate| call.
    for (const auto& open_binding : open_bindings) {
      open_bindings[open_binding.first] = nullptr;
    }
  });
}

TEST(BindingGroup, CloseBindings) {
  ExternalKillBindingTest([](fidl::ServerBindingGroup<Testable>& group, async::Loop* loop,
                             std::vector<TestImpl>& impls,
                             std::map<size_t, const TestImpl*>& open_bindings) {
    const TestImpl* target_impl = &impls[0];
    EXPECT_EQ(group.CloseBindings(target_impl, kTestEpitaph), true);
    EXPECT_EQ(group.CloseBindings(target_impl, kTestEpitaph), false);
    EXPECT_EQ(group.size(), 2);

    // Run the loop until the close handlers are resolved.
    loop->RunUntilIdle();

    // Ensure that the close handler was fired for the closed binding's |impl| the correct
    // number of times.
    EXPECT_EQ(target_impl->get_close_count(), 2);
    for (const auto& impl : impls) {
      if (&impl != target_impl) {
        EXPECT_EQ(impl.get_close_count(), 0);
      }
    }

    // Mark the closed binding as killed, so that the rest of the test knows which bindings
    // should and should not be closed via the client making a |Terminate| call.
    for (const auto& open_binding : open_bindings) {
      if (open_binding.second == target_impl) {
        open_bindings[open_binding.first] = nullptr;
      }
    }
  });
}

TEST(BindingGroup, CloseAll) {
  ExternalKillBindingTest([](fidl::ServerBindingGroup<Testable>& group, async::Loop* loop,
                             std::vector<TestImpl>& impls,
                             std::map<size_t, const TestImpl*>& open_bindings) {
    EXPECT_EQ(group.CloseAll(kTestEpitaph), true);
    EXPECT_EQ(group.CloseAll(kTestEpitaph), false);
    EXPECT_EQ(group.size(), 0);

    // Run the loop until the close handlers are resolved.
    loop->RunUntilIdle();

    // Ensure that the close handler was fired for the closed bindings' |impl|s the correct
    // number of times.
    for (const auto& impl : impls) {
      EXPECT_EQ(impl.get_close_count(), 2);
    }

    // Mark the closed bindings as killed, so that the rest of the test knows which bindings
    // should and should not be closed via the client making a |Terminate| call.
    for (const auto& open_binding : open_bindings) {
      open_bindings[open_binding.first] = nullptr;
    }
  });
}

TEST(BindingGroup, CannotRemoveAfterClose) {
  ExternalKillBindingTest([](fidl::ServerBindingGroup<Testable>& group, async::Loop* loop,
                             std::vector<TestImpl>& impls,
                             std::map<size_t, const TestImpl*>& open_bindings) {
    const TestImpl* target_impl = &impls[1];
    EXPECT_EQ(group.CloseBindings(target_impl, kTestEpitaph), true);
    EXPECT_EQ(group.RemoveBindings(target_impl), false);
    EXPECT_EQ(group.size(), 2);
    EXPECT_EQ(group.CloseAll(kTestEpitaph), true);
    EXPECT_EQ(group.RemoveAll(), false);
    EXPECT_EQ(group.size(), 0);

    // Run the loop until the close handlers are resolved.
    loop->RunUntilIdle();

    // Ensure that the close handler was fired for the closed bindings' |impl|s the correct
    // number of times.
    for (const auto& impl : impls) {
      EXPECT_EQ(impl.get_close_count(), 2);
    }

    // Mark the closed bindings as killed, so that the rest of the test knows which bindings
    // should and should not be closed via the client making a |Terminate| call.
    for (const auto& open_binding : open_bindings) {
      open_bindings[open_binding.first] = nullptr;
    }
  });
}

TEST(BindingGroup, CannotCloseAfterRemove) {
  ExternalKillBindingTest([](fidl::ServerBindingGroup<Testable>& group, async::Loop* loop,
                             std::vector<TestImpl>& impls,
                             std::map<size_t, const TestImpl*>& open_bindings) {
    const TestImpl* target_impl = &impls[1];
    EXPECT_EQ(group.RemoveBindings(target_impl), true);
    EXPECT_EQ(group.CloseBindings(target_impl, kTestEpitaph), false);
    EXPECT_EQ(group.size(), 2);
    EXPECT_EQ(group.RemoveAll(), true);
    EXPECT_EQ(group.CloseAll(kTestEpitaph), false);
    EXPECT_EQ(group.size(), 0);

    loop->RunUntilIdle();

    // Ensure that no close counters were incremented, since this was merely a removal.
    for (auto& impl : open_bindings) {
      EXPECT_EQ(impl.second->get_close_count(), 0);
    }

    // Mark the removed bindings as killed, so that the rest of the test knows which bindings
    // should and should not be closed via the client making a |Terminate| call.
    for (const auto& open_binding : open_bindings) {
      open_bindings[open_binding.first] = nullptr;
    }
  });
}

// These classes are used to create a server implementation with multiple
// inheritance.
class PlaceholderBase1 {
 public:
  virtual void Foo() = 0;
  int a;
};

class PlaceholderBase2 {
 public:
  virtual void Bar() = 0;
  int b;
};

class MultiInheritanceServer : public PlaceholderBase1,
                               public fidl::Server<fidl_cpp_wire_bindinggroup_test::Foo>,
                               public fidl::Server<Testable>,
                               public fidl::WireServer<fidl_cpp_wire_bindinggroup_test::Bar>,
                               public PlaceholderBase2 {
 public:
  MultiInheritanceServer() = default;
  MultiInheritanceServer(MultiInheritanceServer&& other) = delete;
  MultiInheritanceServer(const MultiInheritanceServer& other) = delete;
  MultiInheritanceServer& operator=(MultiInheritanceServer&& other) = delete;
  MultiInheritanceServer& operator=(const MultiInheritanceServer& other) = delete;

  void Foo() override {}
  void Bar() override {}

  void Echo(EchoRequest& request, EchoCompleter::Sync& completer) override {
    completer.Reply(request.str());
  }

  void Terminate(TerminateCompleter::Sync& completer) override { completer.Close(kTestEpitaph); }
};

TEST(BindingGroup, DisambiguateMultiProtocolImplementations) {
  async::Loop loop(&kAsyncLoopConfigNeverAttachToThread);
  fidl::ServerBindingGroup<Testable> binding_group;
  MultiInheritanceServer impl;
  auto endpoints = fidl::Endpoints<Testable>::Create();
  binding_group.AddBinding(loop.dispatcher(), std::move(endpoints.server), &impl,
                           fidl::kIgnoreBindingClosure);
  fidl::Client client(std::move(endpoints.client), loop.dispatcher());
  client->Echo({"test"}).ThenExactlyOnce([&](fidl::Result<Testable::Echo>& result) {
    loop.Quit();
    ASSERT_TRUE(result.is_ok());
    EXPECT_EQ("test", result->str());
  });
  loop.Run();
}

}  // namespace