src/lib/fidl/llcpp/tests/integration/handle_raii_test.cc

// Copyright 2020 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/llcpptest.handleraii.test/cpp/wire.h>
#include <lib/async-loop/cpp/loop.h>
#include <lib/async-loop/default.h>
#include <lib/async/wait.h>
#include <lib/fidl/cpp/wire/arena.h>
#include <lib/fidl/cpp/wire/object_view.h>
#include <lib/fidl/cpp/wire/server.h>
#include <lib/fidl/cpp/wire/vector_view.h>
#include <lib/zx/object.h>
#include <zircon/errors.h>
#include <zircon/fidl.h>
#include <zircon/status.h>
#include <zircon/syscalls/object.h>

#include <cstdint>

#include <gtest/gtest.h>
#include <src/lib/fidl/llcpp/tests/types_test_utils.h>

namespace test = ::llcpptest_handleraii_test;

// All the tests in this file check that when a result is freed, all the handles inside the result
// are closed.

class HandleCloseProviderServer : public fidl::WireServer<test::HandleProvider> {
 public:
  void GetHandle(GetHandleCompleter::Sync& completer) override {
    zx::event e;
    zx::event::create(0, &e);
    completer.Reply(std::move(e));
  }
  void GetHandleStruct(GetHandleStructCompleter::Sync& completer) override {
    test::wire::HandleStruct s;
    zx::event::create(0, &s.h);
    completer.Reply(std::move(s));
  }
  void GetHandleStructStruct(GetHandleStructStructCompleter::Sync& completer) override {
    test::wire::HandleStructStruct s;
    zx::event::create(0, &s.s.h);
    completer.Reply(std::move(s));
  }
  void GetMultiFieldStruct(GetMultiFieldStructCompleter::Sync& completer) override {
    test::wire::MultiFieldStruct s;
    zx::event::create(0, &s.h1);
    zx::event::create(0, &s.s.h);
    zx::event::create(0, &s.h2);
    completer.Reply(std::move(s));
  }
  void GetMultiArgs(GetMultiArgsCompleter::Sync& completer) override {
    zx::event h1;
    zx::event::create(0, &h1);
    test::wire::HandleStruct s;
    zx::event::create(0, &s.h);
    zx::event h2;
    zx::event::create(0, &h2);
    completer.Reply(std::move(h1), std::move(s), std::move(h2));
  }
  void GetVectorStruct(GetVectorStructRequestView request,
                       GetVectorStructCompleter::Sync& completer) override {
    fidl::Arena allocator;
    fidl::VectorView<test::wire::HandleStruct> v(allocator, request->count);
    for (auto& s : v) {
      zx::event::create(0, &s.h);
    }
    test::wire::VectorStruct s;
    s.v = std::move(v);
    completer.Reply(std::move(s));
  }
  void GetArrayStruct(GetArrayStructCompleter::Sync& completer) override {
    test::wire::ArrayStruct s;
    for (size_t i = 0; i < s.a.size(); ++i) {
      zx::event::create(0, &s.a[i].h);
    }
    completer.Reply(std::move(s));
  }
  void GetHandleUnion(GetHandleUnionRequestView request,
                      GetHandleUnionCompleter::Sync& completer) override {
    test::wire::HandleUnion u;
    if (request->field == 1) {
      u = test::wire::HandleUnion::WithH1(zx::event());
      zx::event::create(0, &u.h1());
    } else if (request->field == 2) {
      u = test::wire::HandleUnion::WithH2(test::wire::HandleStruct());
      zx::event::create(0, &u.h2().h);
    }
    completer.Reply(std::move(u));
  }
  void GetHandleUnionStruct(GetHandleUnionStructRequestView request,
                            GetHandleUnionStructCompleter::Sync& completer) override {
    test::wire::HandleUnionStruct u;
    if (request->field == 1) {
      zx::event event;
      zx::event::create(0, &event);
      u.u = test::wire::HandleUnion::WithH1(std::move(event));
    } else if (request->field == 2) {
      u.u = test::wire::HandleUnion::WithH2(test::wire::HandleStruct());
      zx::event::create(0, &u.u.h2().h);
    }
    completer.Reply(std::move(u));
  }
  void GetHandleTable(GetHandleTableRequestView request,
                      GetHandleTableCompleter::Sync& completer) override {
    fidl::Arena allocator;
    auto builder = test::wire::HandleTable::Builder(allocator);
    if ((request->fields & 1) != 0) {
      zx::event event;
      zx::event::create(0, &event);
      builder.h1(std::move(event));
    }
    if ((request->fields & 2) != 0) {
      test::wire::HandleStruct hs{};
      zx::event::create(0, &hs.h);
      builder.h2(std::move(hs));
    }
    completer.Reply(builder.Build());
  }
  void GetHandleTableStruct(GetHandleTableStructRequestView request,
                            GetHandleTableStructCompleter::Sync& completer) override {
    fidl::Arena allocator;
    test::wire::HandleTableStruct reply;
    auto builder = test::wire::HandleTable::Builder(allocator);
    if ((request->fields & 1) != 0) {
      zx::event event;
      zx::event::create(0, &event);
      builder.h1(std::move(event));
    }
    if ((request->fields & 2) != 0) {
      test::wire::HandleStruct hs{};
      zx::event::create(0, &hs.h);
      builder.h2(std::move(hs));
    }
    reply.t = builder.Build();
    completer.Reply(std::move(reply));
  }
  void GetOptionalHandleStruct(GetOptionalHandleStructRequestView request,
                               GetOptionalHandleStructCompleter::Sync& completer) override {
    fidl::Arena allocator;
    if (request->defined) {
      fidl::ObjectView<test::wire::HandleStruct> s(allocator);
      zx::event::create(0, &s->h);
      completer.Reply(s);
    } else {
      completer.Reply(nullptr);
    }
  }
  void GetOptionalHandleUnion(GetOptionalHandleUnionRequestView request,
                              GetOptionalHandleUnionCompleter::Sync& completer) override {
    fidl::Arena allocator;
    test::wire::HandleUnion u;
    if (request->field == 1) {
      zx::event event;
      zx::event::create(0, &event);
      u = test::wire::HandleUnion::WithH1(std::move(event));
    } else if (request->field == 2) {
      u = test::wire::HandleUnion::WithH2(test::wire::HandleStruct());
      zx::event::create(0, &u.h2().h);
    }
    completer.Reply(std::move(u));
  }
  void GetOptionalHandleUnionStruct(
      GetOptionalHandleUnionStructRequestView request,
      GetOptionalHandleUnionStructCompleter::Sync& completer) override {
    if (request->defined) {
      fidl::Arena allocator;
      fidl::ObjectView<test::wire::HandleUnionStruct> u(allocator);
      if (request->field == 1) {
        zx::event event;
        zx::event::create(0, &event);
        u->u = test::wire::HandleUnion::WithH1(std::move(event));
      } else if (request->field == 2) {
        u->u = test::wire::HandleUnion::WithH2(test::wire::HandleStruct());
        zx::event::create(0, &u->u.h2().h);
      }
      completer.Reply(u);
    } else {
      completer.Reply(nullptr);
    }
  }
  void GetOptionalHandleTableStruct(
      GetOptionalHandleTableStructRequestView request,
      GetOptionalHandleTableStructCompleter::Sync& completer) override {
    if (request->defined) {
      fidl::Arena allocator;
      fidl::ObjectView<test::wire::HandleTableStruct> reply(allocator);
      auto builder = test::wire::HandleTable::Builder(allocator);
      if ((request->fields & 1) != 0) {
        zx::event e;
        zx::event::create(0, &e);
        builder.h1(std::move(e));
      }
      if ((request->fields & 2) != 0) {
        test::wire::HandleStruct s;
        zx::event::create(0, &s.h);
        builder.h2(std::move(s));
      }
      reply->t = builder.Build();
      completer.Reply(reply);
    } else {
      completer.Reply(nullptr);
    }
  }
  void GetHandleStructOptionalStruct(
      GetHandleStructOptionalStructRequestView request,
      GetHandleStructOptionalStructCompleter::Sync& completer) override {
    fidl::Arena allocator;
    test::wire::HandleStructOptionalStruct reply;
    if (request->defined) {
      fidl::ObjectView<test::wire::HandleStruct> s(allocator);
      zx::event::create(0, &s->h);
      reply.s = s;
    }
    completer.Reply(std::move(reply));
  }
  void GetHandleUnionOptionalStruct(
      GetHandleUnionOptionalStructRequestView request,
      GetHandleUnionOptionalStructCompleter::Sync& completer) override {
    fidl::Arena allocator;
    test::wire::HandleUnionOptionalStruct reply;
    if (request->defined) {
      if (request->field == 1) {
        zx::event event;
        zx::event::create(0, &event);
        reply.u = test::wire::HandleUnion::WithH1(std::move(event));
      } else if (request->field == 2) {
        reply.u = test::wire::HandleUnion::WithH2(test::wire::HandleStruct());
        zx::event::create(0, &reply.u->h2().h);
      }
    }
    completer.Reply(std::move(reply));
  }
  void GetVectorOfHandle(GetVectorOfHandleRequestView request,
                         GetVectorOfHandleCompleter::Sync& completer) override {
    fidl::Arena allocator;
    fidl::VectorView<zx::event> v(allocator, request->count);
    for (auto& item : v) {
      zx::event::create(0, &item);
    }
    completer.Reply(std::move(v));
  }
  void GetVectorOfVectorOfHandle(GetVectorOfVectorOfHandleRequestView request,
                                 GetVectorOfVectorOfHandleCompleter::Sync& completer) override {
    fidl::Arena allocator;
    fidl::VectorView<fidl::VectorView<zx::event>> v(allocator, request->count1);
    for (uint32_t i1 = 0; i1 < request->count1; ++i1) {
      v[i1].Allocate(allocator, request->count2);
      for (uint32_t i2 = 0; i2 < request->count2; ++i2) {
        zx::event::create(0, &v[i1][i2]);
      }
    }
    completer.Reply(std::move(v));
  }
  void GetVectorOfVectorOfVectorOfHandle(
      GetVectorOfVectorOfVectorOfHandleRequestView request,
      GetVectorOfVectorOfVectorOfHandleCompleter::Sync& completer) override {
    fidl::Arena allocator;
    fidl::VectorView<fidl::VectorView<fidl::VectorView<zx::event>>> v(allocator, request->count1);
    for (uint32_t i1 = 0; i1 < request->count1; ++i1) {
      v[i1].Allocate(allocator, request->count2);
      for (uint32_t i2 = 0; i2 < request->count2; ++i2) {
        v[i1][i2].Allocate(allocator, request->count3);
        for (uint32_t i3 = 0; i3 < request->count3; ++i3) {
          zx::event::create(0, &v[i1][i2][i3]);
        }
      }
    }
    completer.Reply(std::move(v));
  }
  void GetVectorOfHandleStruct(GetVectorOfHandleStructRequestView request,
                               GetVectorOfHandleStructCompleter::Sync& completer) override {
    fidl::Arena allocator;
    fidl::VectorView<test::wire::HandleStruct> v(allocator, request->count);
    for (auto& item : v) {
      zx::event::create(0, &item.h);
    }
    completer.Reply(std::move(v));
  }
  void GetVectorOfVectorOfHandleStruct(
      GetVectorOfVectorOfHandleStructRequestView request,
      GetVectorOfVectorOfHandleStructCompleter::Sync& completer) override {
    fidl::Arena allocator;
    fidl::VectorView<fidl::VectorView<test::wire::HandleStruct>> v(allocator, request->count1);
    for (uint32_t i1 = 0; i1 < request->count1; ++i1) {
      v[i1].Allocate(allocator, request->count2);
      for (uint32_t i2 = 0; i2 < request->count2; ++i2) {
        zx::event::create(0, &v[i1][i2].h);
      }
    }
    completer.Reply(std::move(v));
  }
  void GetVectorOfVectorOfVectorOfHandleStruct(
      GetVectorOfVectorOfVectorOfHandleStructRequestView request,
      GetVectorOfVectorOfVectorOfHandleStructCompleter::Sync& completer) override {
    fidl::Arena allocator;
    fidl::VectorView<fidl::VectorView<fidl::VectorView<test::wire::HandleStruct>>> v(
        allocator, request->count1);
    for (uint32_t i1 = 0; i1 < request->count1; ++i1) {
      v[i1].Allocate(allocator, request->count2);
      for (uint32_t i2 = 0; i2 < request->count2; ++i2) {
        v[i1][i2].Allocate(allocator, request->count3);
        for (uint32_t i3 = 0; i3 < request->count3; ++i3) {
          zx::event::create(0, &v[i1][i2][i3].h);
        }
      }
    }
    completer.Reply(std::move(v));
  }
  void GetArrayOfHandle(GetArrayOfHandleCompleter::Sync& completer) override {
    fidl::Array<zx::event, 2> a;
    for (auto& item : a) {
      zx::event::create(0, &item);
    }
    completer.Reply(std::move(a));
  }
  void GetArrayOfArrayOfHandle(GetArrayOfArrayOfHandleCompleter::Sync& completer) override {
    fidl::Array<fidl::Array<zx::event, 2>, 3> a;
    for (auto& item1 : a) {
      for (auto& item2 : item1) {
        zx::event::create(0, &item2);
      }
    }
    completer.Reply(std::move(a));
  }
  void GetArrayOfArrayOfArrayOfHandle(
      GetArrayOfArrayOfArrayOfHandleCompleter::Sync& completer) override {
    fidl::Array<fidl::Array<fidl::Array<zx::event, 2>, 3>, 4> a;
    for (auto& item1 : a) {
      for (auto& item2 : item1) {
        for (auto& item3 : item2) {
          zx::event::create(0, &item3);
        }
      }
    }
    completer.Reply(std::move(a));
  }
  void GetArrayOfHandleStruct(GetArrayOfHandleStructCompleter::Sync& completer) override {
    fidl::Array<test::wire::HandleStruct, 2> a;
    for (auto& item : a) {
      zx::event::create(0, &item.h);
    }
    completer.Reply(std::move(a));
  }
  void GetArrayOfArrayOfHandleStruct(
      GetArrayOfArrayOfHandleStructCompleter::Sync& completer) override {
    fidl::Array<fidl::Array<test::wire::HandleStruct, 2>, 3> a;
    for (auto& item1 : a) {
      for (auto& item2 : item1) {
        zx::event::create(0, &item2.h);
      }
    }
    completer.Reply(std::move(a));
  }
  void GetArrayOfArrayOfArrayOfHandleStruct(
      GetArrayOfArrayOfArrayOfHandleStructCompleter::Sync& completer) override {
    fidl::Array<fidl::Array<fidl::Array<test::wire::HandleStruct, 2>, 3>, 4> a;
    for (auto& item1 : a) {
      for (auto& item2 : item1) {
        for (auto& item3 : item2) {
          zx::event::create(0, &item3.h);
        }
      }
    }
    completer.Reply(std::move(a));
  }
  void GetMixed1(GetMixed1RequestView request, GetMixed1Completer::Sync& completer) override {
    fidl::Arena allocator;
    fidl::Array<fidl::VectorView<zx::event>, 2> a;
    for (auto& item1 : a) {
      item1.Allocate(allocator, request->count);
      for (auto& item2 : item1) {
        zx::event::create(0, &item2);
      }
    }
    completer.Reply(std::move(a));
  }
  void GetMixed2(GetMixed2RequestView request, GetMixed2Completer::Sync& completer) override {
    fidl::Arena allocator;
    fidl::VectorView<fidl::Array<zx::event, 2>> v(allocator, request->count);
    for (auto& item1 : v) {
      for (auto& item2 : item1) {
        zx::event::create(0, &item2);
      }
    }
    completer.Reply(std::move(v));
  }
};

class HandleCloseTest : public ::testing::Test {
 protected:
  virtual void SetUp() {
    loop_ = std::make_unique<async::Loop>(&kAsyncLoopConfigAttachToCurrentThread);
    ASSERT_EQ(loop_->StartThread("test_llcpp_handle_server"), ZX_OK);

    auto endpoints = fidl::Endpoints<test::HandleProvider>::Create();
    client_end_ = std::move(endpoints.client);
    server_ = std::make_unique<HandleCloseProviderServer>();
    fidl::BindServer(loop_->dispatcher(), std::move(endpoints.server), server_.get());
  }

  fidl::WireSyncClient<test::HandleProvider> TakeClient() {
    EXPECT_TRUE(client_end_.is_valid());
    return fidl::WireSyncClient<test::HandleProvider>(std::move(client_end_));
  }

 private:
  std::unique_ptr<async::Loop> loop_;
  std::unique_ptr<HandleCloseProviderServer> server_;
  fidl::ClientEnd<test::HandleProvider> client_end_;
};

TEST_F(HandleCloseTest, Handle) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetHandle();

    ASSERT_TRUE(result.ok()) << result.error();

    checker.AddEvent(result.value().value);
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, HandleStruct) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetHandleStruct();

    ASSERT_TRUE(result.ok()) << result.error();

    checker.AddEvent(result.value().value.h);
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, HandleStructStruct) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetHandleStructStruct();

    ASSERT_TRUE(result.ok()) << result.error();

    checker.AddEvent(result.value().value.s.h);
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, MultiFieldStruct) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetMultiFieldStruct();

    ASSERT_TRUE(result.ok()) << result.error();

    checker.AddEvent(result.value().value.h1);
    checker.AddEvent(result.value().value.s.h);
    checker.AddEvent(result.value().value.h2);
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, MultiArgs) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetMultiArgs();

    ASSERT_TRUE(result.ok()) << result.error();

    checker.AddEvent(result.value().h1);
    checker.AddEvent(result.value().s.h);
    checker.AddEvent(result.value().h2);
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, VectorStruct) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetVectorStruct(4);

    ASSERT_TRUE(result.ok()) << result.error();

    for (uint32_t i = 0; i < result.value().value.v.size(); ++i) {
      checker.AddEvent(result.value().value.v[i].h);
    }
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, ArrayStruct) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetArrayStruct();

    ASSERT_TRUE(result.ok()) << result.error();

    for (size_t i = 0; i < result.value().value.a.size(); ++i) {
      checker.AddEvent(result.value().value.a[i].h);
    }
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, HandleUnion1) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetHandleUnion(1);

    ASSERT_TRUE(result.ok()) << result.error();

    ASSERT_TRUE(result.value().value.is_h1());
    checker.AddEvent(result.value().value.h1());
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, HandleUnion2) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetHandleUnion(2);

    ASSERT_TRUE(result.ok()) << result.error();

    ASSERT_TRUE(result.value().value.is_h2());
    checker.AddEvent(result.value().value.h2().h);
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, HandleUnionStruct1) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetHandleUnionStruct(1);

    ASSERT_TRUE(result.ok()) << result.error();

    ASSERT_TRUE(result.value().value.u.is_h1());
    checker.AddEvent(result.value().value.u.h1());
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, HandleUnionStruct2) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetHandleUnionStruct(2);

    ASSERT_TRUE(result.ok()) << result.error();

    ASSERT_TRUE(result.value().value.u.is_h2());
    checker.AddEvent(result.value().value.u.h2().h);
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, HandleTableNone) {
  // Only checks that the destructions won't crash.
  auto client = TakeClient();
  {
    auto result = client->GetHandleTable(0);

    ASSERT_TRUE(result.ok()) << result.error();
  }
}

TEST_F(HandleCloseTest, HandleTableEvent) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetHandleTable(1);

    ASSERT_TRUE(result.ok()) << result.error();

    checker.AddEvent(result.value().value.h1());
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, HandleTableHandleStruct) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetHandleTable(2);

    ASSERT_TRUE(result.ok()) << result.error();

    checker.AddEvent(result.value().value.h2().h);
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, HandleTableAll) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetHandleTable(3);

    ASSERT_TRUE(result.ok()) << result.error();

    checker.AddEvent(result.value().value.h1());
    checker.AddEvent(result.value().value.h2().h);
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, HandleTableStructNone) {
  // Only checks that the destructions won't crash.
  auto client = TakeClient();
  {
    auto result = client->GetHandleTableStruct(0);

    ASSERT_TRUE(result.ok()) << result.error();
  }
}

TEST_F(HandleCloseTest, HandleTableStructEvent) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetHandleTableStruct(1);

    ASSERT_TRUE(result.ok()) << result.error();

    checker.AddEvent(result.value().value.t.h1());
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, HandleTableStructHandleStruct) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetHandleTableStruct(2);

    ASSERT_TRUE(result.ok()) << result.error();

    checker.AddEvent(result.value().value.t.h2().h);
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, HandleTableStructAll) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetHandleTableStruct(3);

    ASSERT_TRUE(result.ok()) << result.error();

    checker.AddEvent(result.value().value.t.h1());
    checker.AddEvent(result.value().value.t.h2().h);
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, OptionalHandleStructNotDefined) {
  // Only checks that the destructions won't crash.
  auto client = TakeClient();
  {
    auto result = client->GetOptionalHandleStruct(false);

    ASSERT_TRUE(result.ok()) << result.error();
  }
}

TEST_F(HandleCloseTest, OptionalHandleStructDefined) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetOptionalHandleStruct(true);

    ASSERT_TRUE(result.ok()) << result.error();

    checker.AddEvent(result.value().value->h);
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, OptionalHandleUnionNone) {
  // Only checks that the destructions won't crash.
  auto client = TakeClient();
  {
    auto result = client->GetOptionalHandleUnion(0);

    ASSERT_TRUE(result.ok()) << result.error();
  }
}

TEST_F(HandleCloseTest, OptionalHandleUnion1) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetOptionalHandleUnion(1);

    ASSERT_TRUE(result.ok()) << result.error();

    ASSERT_TRUE(result.value().value.has_value());
    ASSERT_TRUE(result.value().value->is_h1());
    checker.AddEvent(result.value().value->h1());
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, OptionalHandleUnion2) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetOptionalHandleUnion(2);

    ASSERT_TRUE(result.ok()) << result.error();

    ASSERT_TRUE(result.value().value.has_value());
    ASSERT_TRUE(result.value().value->is_h2());
    checker.AddEvent(result.value().value->h2().h);
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, OptionalHandleUnionStructNotDefined) {
  // Only checks that the destructions won't crash.
  auto client = TakeClient();
  {
    auto result = client->GetOptionalHandleUnionStruct(false, 0);

    ASSERT_TRUE(result.ok()) << result.error();
  }
}

TEST_F(HandleCloseTest, OptionalHandleUnionStruct1) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetOptionalHandleUnionStruct(true, 1);

    ASSERT_TRUE(result.ok()) << result.error();

    ASSERT_TRUE(result.value().value->u.is_h1());
    checker.AddEvent(result.value().value->u.h1());
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, OptionalHandleUnionStruct2) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetOptionalHandleUnionStruct(true, 2);

    ASSERT_TRUE(result.ok()) << result.error();

    ASSERT_TRUE(result.value().value->u.is_h2());
    checker.AddEvent(result.value().value->u.h2().h);
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, OptionalHandleTableStructNotDefined) {
  // Only checks that the destructions won't crash.
  auto client = TakeClient();
  {
    auto result = client->GetOptionalHandleTableStruct(false, 0);

    ASSERT_TRUE(result.ok()) << result.error();
  }
}

TEST_F(HandleCloseTest, OptionalHandleTableStructNone) {
  // Only checks that the destructions won't crash.
  auto client = TakeClient();
  {
    auto result = client->GetOptionalHandleTableStruct(true, 0);

    ASSERT_TRUE(result.ok()) << result.error();
  }
}

TEST_F(HandleCloseTest, OptionalHandleTableStructEvent) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetOptionalHandleTableStruct(true, 1);

    ASSERT_TRUE(result.ok()) << result.error();

    checker.AddEvent(result.value().value->t.h1());
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, OptionalHandleTableStructHandleStruct) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetOptionalHandleTableStruct(true, 2);

    ASSERT_TRUE(result.ok()) << result.error();

    checker.AddEvent(result.value().value->t.h2().h);
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, OptionalHandleTableStructAll) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetOptionalHandleTableStruct(true, 3);

    ASSERT_TRUE(result.ok()) << result.error();

    checker.AddEvent(result.value().value->t.h1());
    checker.AddEvent(result.value().value->t.h2().h);
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, HandleStructOptionalStructNotDefined) {
  // Only checks that the destructions won't crash.
  auto client = TakeClient();
  {
    auto result = client->GetHandleStructOptionalStruct(false);

    ASSERT_TRUE(result.ok()) << result.error();
  }
}

TEST_F(HandleCloseTest, HandleStructOptionalStructDefined) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetHandleStructOptionalStruct(true);

    ASSERT_TRUE(result.ok()) << result.error();

    checker.AddEvent(result.value().value.s->h);
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, HandleUnionOptionalStructNotDefined) {
  // Only checks that the destructions won't crash.
  auto client = TakeClient();
  {
    auto result = client->GetHandleUnionOptionalStruct(false, 0);

    ASSERT_TRUE(result.ok()) << result.error();
  }
}

TEST_F(HandleCloseTest, HandleUnionOptionalStruct1) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetHandleUnionOptionalStruct(true, 1);

    ASSERT_TRUE(result.ok()) << result.error();

    ASSERT_TRUE(result.value().value.u.has_value());
    ASSERT_TRUE(result.value().value.u->is_h1());
    checker.AddEvent(result.value().value.u->h1());
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, HandleUnionOptionalStruct2) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetHandleUnionOptionalStruct(true, 2);

    ASSERT_TRUE(result.ok()) << result.error();

    ASSERT_TRUE(result.value().value.u.has_value());
    ASSERT_TRUE(result.value().value.u->is_h2());
    checker.AddEvent(result.value().value.u->h2().h);
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, VectorOfHandle) {
  constexpr size_t kNumHandle = 5;
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetVectorOfHandle(kNumHandle);

    ASSERT_TRUE(result.ok()) << result.error();

    for (uint32_t i = 0; i < result.value().value.size(); ++i) {
      checker.AddEvent(result.value().value[i]);
    }
  }

  ASSERT_EQ(checker.size(), kNumHandle);
  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, VectorOfVectorOfHandle) {
  constexpr size_t kNumVector = 4;
  constexpr size_t kNumHandle = 5;
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetVectorOfVectorOfHandle(kNumVector, kNumHandle);

    ASSERT_TRUE(result.ok()) << result.error();

    for (uint32_t i = 0; i < result.value().value.size(); ++i) {
      for (uint32_t j = 0; j < result.value().value[i].size(); ++j) {
        checker.AddEvent(result.value().value[i][j]);
      }
    }
  }

  ASSERT_EQ(checker.size(), kNumVector * kNumHandle);
  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, VectorOfVectorOfVectorOfHandle) {
  constexpr size_t kNumVector1 = 3;
  constexpr size_t kNumVector2 = 4;
  constexpr size_t kNumHandle = 5;
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetVectorOfVectorOfVectorOfHandle(kNumVector1, kNumVector2, kNumHandle);

    ASSERT_TRUE(result.ok()) << result.error();

    for (uint32_t i = 0; i < result.value().value.size(); ++i) {
      for (uint32_t j = 0; j < result.value().value[i].size(); ++j) {
        for (uint32_t k = 0; k < result.value().value[i][j].size(); ++k) {
          checker.AddEvent(result.value().value[i][j][k]);
        }
      }
    }
  }

  ASSERT_EQ(checker.size(), kNumVector1 * kNumVector2 * kNumHandle);
  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, VectorOfHandleStruct) {
  constexpr size_t kNumHandle = 5;
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetVectorOfHandleStruct(kNumHandle);

    ASSERT_TRUE(result.ok()) << result.error();

    for (uint32_t i = 0; i < result.value().value.size(); ++i) {
      checker.AddEvent(result.value().value[i].h);
    }
  }

  ASSERT_EQ(checker.size(), kNumHandle);
  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, VectorOfVectorOfHandleStruct) {
  constexpr size_t kNumVector = 4;
  constexpr size_t kNumHandle = 5;
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetVectorOfVectorOfHandleStruct(kNumVector, kNumHandle);

    ASSERT_TRUE(result.ok()) << result.error();

    for (uint32_t i = 0; i < result.value().value.size(); ++i) {
      for (uint32_t j = 0; j < result.value().value[i].size(); ++j) {
        checker.AddEvent(result.value().value[i][j].h);
      }
    }
  }

  ASSERT_EQ(checker.size(), kNumVector * kNumHandle);
  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, VectorOfVectorOfVectorOfHandleStruct) {
  constexpr size_t kNumVector1 = 3;
  constexpr size_t kNumVector2 = 4;
  constexpr size_t kNumHandle = 5;
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result =
        client->GetVectorOfVectorOfVectorOfHandleStruct(kNumVector1, kNumVector2, kNumHandle);

    ASSERT_TRUE(result.ok()) << result.error();

    for (uint32_t i = 0; i < result.value().value.size(); ++i) {
      for (uint32_t j = 0; j < result.value().value[i].size(); ++j) {
        for (uint32_t k = 0; k < result.value().value[i][j].size(); ++k) {
          checker.AddEvent(result.value().value[i][j][k].h);
        }
      }
    }
  }

  ASSERT_EQ(checker.size(), kNumVector1 * kNumVector2 * kNumHandle);
  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, ArrayOfHandle) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetArrayOfHandle();

    ASSERT_TRUE(result.ok()) << result.error();

    for (auto& item : result.value().value) {
      checker.AddEvent(item);
    }
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, ArrayOfArrayOfHandle) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetArrayOfArrayOfHandle();

    ASSERT_TRUE(result.ok()) << result.error();

    for (auto& item1 : result.value().value) {
      for (const auto& item2 : item1) {
        checker.AddEvent(item2);
      }
    }
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, ArrayOfArrayOfArrayOfHandle) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetArrayOfArrayOfArrayOfHandle();

    ASSERT_TRUE(result.ok()) << result.error();

    for (auto& item1 : result.value().value) {
      for (const auto& item2 : item1) {
        for (const auto& item3 : item2) {
          checker.AddEvent(item3);
        }
      }
    }
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, ArrayOfHandleStruct) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetArrayOfHandleStruct();

    ASSERT_TRUE(result.ok()) << result.error();

    for (auto& item : result.value().value) {
      checker.AddEvent(item.h);
    }
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, ArrayOfArrayOfHandleStruct) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetArrayOfArrayOfHandleStruct();

    ASSERT_TRUE(result.ok()) << result.error();

    for (auto& item1 : result.value().value) {
      for (const auto& item2 : item1) {
        checker.AddEvent(item2.h);
      }
    }
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, ArrayOfArrayOfArrayOfHandleStruct) {
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetArrayOfArrayOfArrayOfHandleStruct();

    ASSERT_TRUE(result.ok()) << result.error();

    for (auto& item1 : result.value().value) {
      for (const auto& item2 : item1) {
        for (const auto& item3 : item2) {
          checker.AddEvent(item3.h);
        }
      }
    }
  }

  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, Mixed1) {
  constexpr size_t kNumHandle = 5;
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetMixed1(kNumHandle);

    ASSERT_TRUE(result.ok()) << result.error();

    for (auto& item1 : result.value().value) {
      for (const auto& item2 : item1) {
        checker.AddEvent(item2);
      }
    }
  }

  ASSERT_EQ(checker.size(), kNumHandle * 2);
  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}

TEST_F(HandleCloseTest, Mixed2) {
  constexpr size_t kNumHandle = 5;
  llcpp_types_test_utils::HandleChecker checker;
  auto client = TakeClient();
  {
    auto result = client->GetMixed2(kNumHandle);

    ASSERT_TRUE(result.ok()) << result.error();

    for (auto& item1 : result.value().value) {
      for (const auto& item2 : item1) {
        checker.AddEvent(item2);
      }
    }
  }

  ASSERT_EQ(checker.size(), kNumHandle * 2);
  // After the destruction of the result, each handle in dupes should have only one link.
  checker.CheckEvents();
}