| // 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 <lib/async-loop/cpp/loop.h> |
| #include <lib/async-loop/default.h> |
| #include <lib/fidl/cpp/binding.h> |
| #include <lib/zx/time.h> |
| #include <zircon/syscalls.h> |
| #include <zircon/types.h> |
| |
| #include <algorithm> |
| #include <future> |
| #include <optional> |
| |
| #include <test/unknown/interactions/cpp/fidl.h> |
| #include <test/unknown/interactions/cpp/fidl_test_base.h> |
| #include <zxtest/zxtest.h> |
| |
| namespace { |
| namespace test = ::test::unknown_::interactions; |
| |
| class UnknownInteractionsImpl : public test::testing::UnknownInteractionsProtocol_TestBase { |
| void NotImplemented_(const std::string& name) override { |
| ADD_FAILURE("Method %s called unexpectedly", name.c_str()); |
| } |
| }; |
| |
| class UnknownInteractions : public ::zxtest::Test { |
| protected: |
| void SetUp() override { |
| loop_.emplace(&kAsyncLoopConfigAttachToCurrentThread); |
| |
| ASSERT_EQ(zx::channel::create(0, &client_end_, &server_end_), ZX_OK); |
| } |
| |
| async::Loop& loop() { return loop_.value(); } |
| |
| fidl::InterfaceRequest<test::UnknownInteractionsProtocol> TakeServerEnd() { |
| EXPECT_TRUE(server_end_.is_valid()); |
| return fidl::InterfaceRequest<test::UnknownInteractionsProtocol>(std::move(server_end_)); |
| } |
| |
| zx::channel TakeServerChannel() { |
| EXPECT_TRUE(server_end_.is_valid()); |
| return std::move(server_end_); |
| } |
| |
| zx::channel TakeClientChannel() { |
| EXPECT_TRUE(client_end_.is_valid()); |
| return std::move(client_end_); |
| } |
| |
| fidl::SynchronousInterfacePtr<test::UnknownInteractionsProtocol> SyncClient() { |
| EXPECT_TRUE(client_end_.is_valid()); |
| fidl::SynchronousInterfacePtr<test::UnknownInteractionsProtocol> client; |
| client.Bind(std::move(client_end_)); |
| return client; |
| } |
| |
| fidl::InterfacePtr<test::UnknownInteractionsProtocol> AsyncClient() { |
| EXPECT_TRUE(client_end_.is_valid()); |
| fidl::InterfacePtr<test::UnknownInteractionsProtocol> client; |
| client.Bind(std::move(client_end_), loop_->dispatcher()); |
| return client; |
| } |
| |
| private: |
| std::optional<async::Loop> loop_; |
| zx::channel client_end_; |
| zx::channel server_end_; |
| }; |
| |
| constexpr std::array<uint8_t, 4> zero_txid = {0, 0, 0, 0}; |
| |
| // Helper for receiving raw data from a channel. |
| template <uint32_t N> |
| struct ReadResult { |
| // Status from reading. |
| zx_status_t status; |
| // Bytes from the read. |
| std::array<uint8_t, N> buf; |
| // Number of bytes read. |
| uint32_t num_bytes; |
| // Number of handles read. |
| uint32_t num_handles; |
| |
| ReadResult() = delete; |
| // Construct a ReadResult by reading from a channel. |
| explicit ReadResult(const zx::channel& channel) { |
| status = channel.wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED, zx::time::infinite(), |
| nullptr); |
| if (status != ZX_OK) |
| return; |
| status = channel.read(/* flags= */ 0, buf.data(), /* handles= */ nullptr, N, |
| /* num_handles= */ 0, &num_bytes, &num_handles); |
| } |
| |
| // Get the contents of the buffer excluding the transaction ID. |
| std::array<uint8_t, N - 4> buf_excluding_txid() { |
| std::array<uint8_t, N - 4> without_txid; |
| std::copy(buf.begin() + 4, buf.end(), without_txid.begin()); |
| return without_txid; |
| } |
| |
| // Get the transaction id portion of the buffer. |
| std::array<uint8_t, 4> buf_txid() { |
| std::array<uint8_t, 4> txid; |
| std::copy(buf.begin(), buf.begin() + 4, txid.begin()); |
| return txid; |
| } |
| }; |
| |
| template <uint32_t N> |
| struct TwoWayServerResult : public ReadResult<N> { |
| // Status from sending a reply. |
| zx_status_t reply_status; |
| |
| TwoWayServerResult() = delete; |
| using ReadResult<N>::ReadResult; |
| |
| // Helper to send a reply to the read as a two-way message. |
| // Copies the txid (first four) bytes from |buf| into |reply_bytes| and sends |
| // the result on the channel, storing the status in |reply_status|. |
| template <uint32_t M> |
| void reply(const zx::channel& channel, std::array<uint8_t, M> reply_bytes) { |
| std::copy(this->buf.begin(), this->buf.begin() + 4, reply_bytes.begin()); |
| reply_status = channel.write(/* flags= */ 0, reply_bytes.data(), M, /* handles= */ nullptr, |
| /* num_handles= */ 0); |
| } |
| }; |
| |
| TEST_F(UnknownInteractions, OneWayStrictSyncSend) { |
| auto client = SyncClient(); |
| auto server = TakeServerChannel(); |
| EXPECT_EQ(client->StrictOneWay(), ZX_OK); |
| |
| ReadResult<16> received(server); |
| EXPECT_EQ(received.status, ZX_OK); |
| EXPECT_EQ(received.num_bytes, 16u); |
| EXPECT_EQ(received.num_handles, 0u); |
| |
| std::array<uint8_t, 16> expected{ |
| 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, // |
| 0xd5, 0x82, 0xb3, 0x4c, 0x50, 0x81, 0xa5, 0x1f, // |
| }; |
| EXPECT_EQ(received.buf, expected); |
| } |
| |
| TEST_F(UnknownInteractions, OneWayFlexibleSyncSend) { |
| auto client = SyncClient(); |
| auto server = TakeServerChannel(); |
| EXPECT_EQ(client->FlexibleOneWay(), ZX_OK); |
| |
| ReadResult<16> received(server); |
| EXPECT_EQ(received.status, ZX_OK); |
| EXPECT_EQ(received.num_bytes, 16u); |
| EXPECT_EQ(received.num_handles, 0u); |
| |
| std::array<uint8_t, 16> expected{ |
| 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x80, 0x01, // |
| 0xfc, 0x90, 0xbb, 0xe2, 0x7a, 0x27, 0x93, 0x27, // |
| }; |
| EXPECT_EQ(received.buf, expected); |
| } |
| |
| TEST_F(UnknownInteractions, TwoWayStrictSyncSend) { |
| auto client = SyncClient(); |
| auto server = std::async(std::launch::async, [server = TakeServerChannel()]() { |
| TwoWayServerResult<16> result(server); |
| result.reply<16>(server, { |
| 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, // |
| 0xdc, 0xb0, 0x55, 0x70, 0x95, 0x6f, 0xba, 0x73, // |
| }); |
| return result; |
| }); |
| |
| EXPECT_EQ(client->StrictTwoWay(), ZX_OK); |
| |
| auto received = server.get(); |
| EXPECT_EQ(received.status, ZX_OK); |
| EXPECT_EQ(received.num_bytes, 16u); |
| EXPECT_EQ(received.num_handles, 0u); |
| EXPECT_EQ(received.reply_status, ZX_OK); |
| |
| std::array<uint8_t, 12> expected{ |
| 0x02, 0x00, 0x00, 0x01, // |
| 0xdc, 0xb0, 0x55, 0x70, 0x95, 0x6f, 0xba, 0x73, // |
| }; |
| EXPECT_EQ(received.buf_excluding_txid(), expected); |
| EXPECT_NE(received.buf_txid(), zero_txid); |
| } |
| |
| TEST_F(UnknownInteractions, TwoWayStrictErrSyncSend) { |
| auto client = SyncClient(); |
| auto server = std::async(std::launch::async, [server = TakeServerChannel()]() { |
| TwoWayServerResult<16> result(server); |
| result.reply<32>(server, { |
| 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, // |
| 0xbb, 0x58, 0xe0, 0x08, 0x4e, 0xeb, 0x9b, 0x2e, // |
| // Result union with success envelope to satisfy client side: |
| // ordinal ---------------------------------| |
| 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // |
| // inline value -----| nhandles | flags ---| |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, // |
| |
| }); |
| return result; |
| }); |
| |
| test::UnknownInteractionsProtocol_StrictTwoWayErr_Result result; |
| EXPECT_EQ(client->StrictTwoWayErr(&result), ZX_OK); |
| |
| auto received = server.get(); |
| EXPECT_EQ(received.status, ZX_OK); |
| EXPECT_EQ(received.num_bytes, 16u); |
| EXPECT_EQ(received.num_handles, 0u); |
| EXPECT_EQ(received.reply_status, ZX_OK); |
| |
| std::array<uint8_t, 12> expected{ |
| 0x02, 0x00, 0x00, 0x01, // |
| 0xbb, 0x58, 0xe0, 0x08, 0x4e, 0xeb, 0x9b, 0x2e, // |
| }; |
| EXPECT_EQ(received.buf_excluding_txid(), expected); |
| EXPECT_NE(received.buf_txid(), zero_txid); |
| } |
| |
| TEST_F(UnknownInteractions, TwoWayFlexibleSyncSend) { |
| auto client = SyncClient(); |
| auto server = std::async(std::launch::async, [server = TakeServerChannel()]() { |
| TwoWayServerResult<16> result(server); |
| result.reply<32>(server, { |
| 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x80, 0x01, // |
| 0x9d, 0x60, 0x95, 0x03, 0x7a, 0x51, 0x33, 0x1f, // |
| // Result union with success envelope to satisfy client side: |
| // ordinal ---------------------------------| |
| 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // |
| // inline value -----| nhandles | flags ---| |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, // |
| |
| }); |
| return result; |
| }); |
| |
| test::UnknownInteractionsProtocol_FlexibleTwoWay_Result result; |
| EXPECT_EQ(client->FlexibleTwoWay(&result), ZX_OK); |
| |
| auto received = server.get(); |
| EXPECT_EQ(received.status, ZX_OK); |
| EXPECT_EQ(received.num_bytes, 16u); |
| EXPECT_EQ(received.num_handles, 0u); |
| EXPECT_EQ(received.reply_status, ZX_OK); |
| |
| std::array<uint8_t, 12> expected{ |
| 0x02, 0x00, 0x80, 0x01, // |
| 0x9d, 0x60, 0x95, 0x03, 0x7a, 0x51, 0x33, 0x1f, // |
| |
| }; |
| EXPECT_EQ(received.buf_excluding_txid(), expected); |
| EXPECT_NE(received.buf_txid(), zero_txid); |
| } |
| |
| TEST_F(UnknownInteractions, OneWayStrictAsyncSend) { |
| auto client = AsyncClient(); |
| auto server = TakeServerChannel(); |
| client.set_error_handler( |
| [](zx_status_t status) { ADD_FAILURE("Got an error status: %d", status); }); |
| client->StrictOneWay(); |
| |
| ReadResult<16> received(server); |
| EXPECT_EQ(received.status, ZX_OK); |
| EXPECT_EQ(received.num_bytes, 16u); |
| EXPECT_EQ(received.num_handles, 0u); |
| |
| std::array<uint8_t, 16> expected{ |
| 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, // |
| 0xd5, 0x82, 0xb3, 0x4c, 0x50, 0x81, 0xa5, 0x1f, // |
| }; |
| EXPECT_EQ(received.buf, expected); |
| } |
| |
| TEST_F(UnknownInteractions, OneWayFlexibleAsyncSend) { |
| auto client = AsyncClient(); |
| auto server = TakeServerChannel(); |
| client.set_error_handler( |
| [](zx_status_t status) { ADD_FAILURE("Got an error status: %d", status); }); |
| client->FlexibleOneWay(); |
| |
| ReadResult<16> received(server); |
| EXPECT_EQ(received.status, ZX_OK); |
| EXPECT_EQ(received.num_bytes, 16u); |
| EXPECT_EQ(received.num_handles, 0u); |
| |
| std::array<uint8_t, 16> expected{ |
| 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x80, 0x01, // |
| 0xfc, 0x90, 0xbb, 0xe2, 0x7a, 0x27, 0x93, 0x27, // |
| }; |
| EXPECT_EQ(received.buf, expected); |
| } |
| |
| TEST_F(UnknownInteractions, TwoWayStrictAsyncSend) { |
| auto client = AsyncClient(); |
| auto server = TakeServerChannel(); |
| client.set_error_handler( |
| [](zx_status_t status) { ADD_FAILURE("Got an error status: %d", status); }); |
| |
| bool response_received = false; |
| client->StrictTwoWay([&response_received]() { response_received = true; }); |
| |
| TwoWayServerResult<16> received(server); |
| EXPECT_EQ(received.status, ZX_OK); |
| EXPECT_EQ(received.num_bytes, 16u); |
| EXPECT_EQ(received.num_handles, 0u); |
| std::array<uint8_t, 12> expected{ |
| 0x02, 0x00, 0x00, 0x01, // |
| 0xdc, 0xb0, 0x55, 0x70, 0x95, 0x6f, 0xba, 0x73, // |
| }; |
| EXPECT_EQ(received.buf_excluding_txid(), expected); |
| EXPECT_NE(received.buf_txid(), zero_txid); |
| |
| received.reply<16>(server, { |
| 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, // |
| 0xdc, 0xb0, 0x55, 0x70, 0x95, 0x6f, 0xba, 0x73, // |
| }); |
| EXPECT_EQ(received.reply_status, ZX_OK); |
| |
| loop().RunUntilIdle(); |
| EXPECT_TRUE(response_received); |
| } |
| |
| TEST_F(UnknownInteractions, TwoWayStrictErrAsyncSend) { |
| auto client = AsyncClient(); |
| auto server = TakeServerChannel(); |
| client.set_error_handler( |
| [](zx_status_t status) { ADD_FAILURE("Got an error status: %d", status); }); |
| |
| bool response_received = false; |
| client->StrictTwoWayErr([&response_received](auto response) { |
| response_received = true; |
| EXPECT_TRUE(response.is_response()); |
| }); |
| |
| TwoWayServerResult<16> received(server); |
| EXPECT_EQ(received.status, ZX_OK); |
| EXPECT_EQ(received.num_bytes, 16u); |
| EXPECT_EQ(received.num_handles, 0u); |
| std::array<uint8_t, 12> expected{ |
| 0x02, 0x00, 0x00, 0x01, // |
| 0xbb, 0x58, 0xe0, 0x08, 0x4e, 0xeb, 0x9b, 0x2e, // |
| }; |
| EXPECT_EQ(received.buf_excluding_txid(), expected); |
| EXPECT_NE(received.buf_txid(), zero_txid); |
| |
| received.reply<32>(server, { |
| 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, // |
| 0xbb, 0x58, 0xe0, 0x08, 0x4e, 0xeb, 0x9b, 0x2e, // |
| // Result union with success envelope to satisfy client side: |
| // ordinal ---------------------------------| |
| 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // |
| // inline value -----| nhandles | flags ---| |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, // |
| |
| }); |
| EXPECT_EQ(received.reply_status, ZX_OK); |
| |
| loop().RunUntilIdle(); |
| EXPECT_TRUE(response_received); |
| } |
| |
| TEST_F(UnknownInteractions, TwoWayFlexibleAsyncSend) { |
| auto client = AsyncClient(); |
| auto server = TakeServerChannel(); |
| client.set_error_handler( |
| [](zx_status_t status) { ADD_FAILURE("Got an error status: %d", status); }); |
| |
| bool response_received = false; |
| client->FlexibleTwoWay([&response_received](auto response) { response_received = true; }); |
| |
| TwoWayServerResult<16> received(server); |
| EXPECT_EQ(received.status, ZX_OK); |
| EXPECT_EQ(received.num_bytes, 16u); |
| EXPECT_EQ(received.num_handles, 0u); |
| std::array<uint8_t, 12> expected{ |
| 0x02, 0x00, 0x80, 0x01, // |
| 0x9d, 0x60, 0x95, 0x03, 0x7a, 0x51, 0x33, 0x1f, // |
| |
| }; |
| EXPECT_EQ(received.buf_excluding_txid(), expected); |
| EXPECT_NE(received.buf_txid(), zero_txid); |
| |
| received.reply<32>(server, { |
| 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x80, 0x01, // |
| 0x9d, 0x60, 0x95, 0x03, 0x7a, 0x51, 0x33, 0x1f, // |
| // Result union with success envelope to satisfy client side: |
| // ordinal ---------------------------------| |
| 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // |
| // inline value -----| nhandles | flags ---| |
| 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, // |
| |
| }); |
| EXPECT_EQ(received.reply_status, ZX_OK); |
| |
| loop().RunUntilIdle(); |
| EXPECT_TRUE(response_received); |
| } |
| |
| TEST_F(UnknownInteractions, SendStrictEvent) { |
| auto client = TakeClientChannel(); |
| |
| UnknownInteractionsImpl impl; |
| fidl::Binding<test::UnknownInteractionsProtocol> binding(&impl); |
| auto& event_sender = binding.events(); |
| binding.set_error_handler( |
| [](zx_status_t status) { ADD_FAILURE("Got an error status: %d", status); }); |
| binding.Bind(TakeServerEnd()); |
| |
| event_sender.StrictEvent(); |
| |
| ReadResult<16> received(client); |
| EXPECT_EQ(received.status, ZX_OK); |
| EXPECT_EQ(received.num_bytes, 16u); |
| EXPECT_EQ(received.num_handles, 0u); |
| |
| std::array<uint8_t, 16> expected{ |
| 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, // |
| 0x38, 0x27, 0xa3, 0x91, 0x98, 0x41, 0x4b, 0x58, // |
| |
| }; |
| EXPECT_EQ(received.buf, expected); |
| } |
| |
| TEST_F(UnknownInteractions, SendFlexibleEvent) { |
| auto client = TakeClientChannel(); |
| |
| UnknownInteractionsImpl impl; |
| fidl::Binding<test::UnknownInteractionsProtocol> binding(&impl); |
| auto& event_sender = binding.events(); |
| binding.set_error_handler( |
| [](zx_status_t status) { ADD_FAILURE("Got an error status: %d", status); }); |
| binding.Bind(TakeServerEnd()); |
| |
| event_sender.FlexibleEvent(); |
| |
| ReadResult<16> received(client); |
| EXPECT_EQ(received.status, ZX_OK); |
| EXPECT_EQ(received.num_bytes, 16u); |
| EXPECT_EQ(received.num_handles, 0u); |
| |
| std::array<uint8_t, 16> expected{ |
| 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x80, 0x01, // |
| 0x6c, 0x2c, 0x80, 0x0b, 0x8e, 0x1a, 0x7a, 0x31, // |
| }; |
| EXPECT_EQ(received.buf, expected); |
| } |
| } // namespace |
