| // 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/test.unknown.interactions/cpp/wire.h> | |
| #include <fidl/test.unknown.interactions/cpp/wire_test_base.h> | |
| #include <lib/async-loop/cpp/loop.h> | |
| #include <lib/async-loop/default.h> | |
| #include <lib/fidl/cpp/wire/client.h> | |
| #include <lib/fidl/cpp/wire/server.h> | |
| #include <lib/zx/time.h> | |
| #include <zircon/syscalls.h> | |
| #include <zircon/types.h> | |
| #include <algorithm> | |
| #include <future> | |
| #include <optional> | |
| #include <gmock/gmock.h> | |
| #include <gtest/gtest.h> | |
| struct FakeUnknownMethod { | |
| static constexpr uint64_t kOrdinal = 0x10ff10ff10ff10ff; | |
| }; | |
| namespace { | |
| namespace test = ::test_unknown_interactions; | |
| class UnknownInteractionsEventHandlerBase | |
| : public ::fidl::WireAsyncEventHandler<::test::UnknownInteractionsProtocol>, | |
| public ::fidl::WireSyncEventHandler<::test::UnknownInteractionsProtocol> { | |
| void StrictEvent() override { ADD_FAILURE() << "StrictEvent called unexpectedly"; } | |
| void StrictEventFields( | |
| ::fidl::WireEvent< | |
| ::test_unknown_interactions::UnknownInteractionsProtocol::StrictEventFields>*) override { | |
| ADD_FAILURE() << "StrictEventFields called unexpectedly"; | |
| } | |
| void FlexibleEvent() override { ADD_FAILURE() << "FlexibleEvent called unexpectedly"; } | |
| void FlexibleEventFields( | |
| ::fidl::WireEvent< | |
| ::test_unknown_interactions::UnknownInteractionsProtocol::FlexibleEventFields>*) | |
| override { | |
| ADD_FAILURE() << "FlexibleEventFields called unexpectedly"; | |
| } | |
| void handle_unknown_event( | |
| ::fidl::UnknownEventMetadata<::test::UnknownInteractionsProtocol> metadata) override { | |
| ADD_FAILURE() << "Unexpected flexible unknown event"; | |
| } | |
| }; | |
| class UnknownInteractionsServerBase | |
| : public ::fidl::testing::WireTestBase<::test::UnknownInteractionsProtocol> { | |
| void NotImplemented_(const std::string& name, ::fidl::CompleterBase& completer) override { | |
| ADD_FAILURE() << name << " called unexpected."; | |
| } | |
| }; | |
| class UnknownInteractions : public ::testing::Test { | |
| protected: | |
| void SetUp() override { | |
| loop_.emplace(&kAsyncLoopConfigAttachToCurrentThread); | |
| auto endpoints = fidl::Endpoints<test::UnknownInteractionsProtocol>::Create(); | |
| client_end_ = std::move(endpoints.client); | |
| server_end_ = std::move(endpoints.server); | |
| } | |
| async::Loop& loop() { return loop_.value(); } | |
| fidl::ServerEnd<test::UnknownInteractionsProtocol> TakeServerEnd() { | |
| EXPECT_TRUE(server_end_.is_valid()); | |
| return std::move(server_end_); | |
| } | |
| template <typename ServerImpl> | |
| fidl::ServerBindingRef<typename ServerImpl::_EnclosingProtocol> BindServer(ServerImpl* impl) { | |
| return ::fidl::BindServer( | |
| loop().dispatcher(), | |
| fidl::ServerEnd<typename ServerImpl::_EnclosingProtocol>(TakeServerChannel()), impl); | |
| } | |
| zx::channel TakeServerChannel() { | |
| EXPECT_TRUE(server_end_.is_valid()); | |
| return server_end_.TakeChannel(); | |
| } | |
| zx::channel TakeClientChannel() { | |
| EXPECT_TRUE(client_end_.is_valid()); | |
| return client_end_.TakeChannel(); | |
| } | |
| fidl::WireSyncClient<test::UnknownInteractionsProtocol> SyncClient() { | |
| EXPECT_TRUE(client_end_.is_valid()); | |
| return fidl::WireSyncClient<test::UnknownInteractionsProtocol>(std::move(client_end_)); | |
| } | |
| fidl::WireClient<test::UnknownInteractionsProtocol> AsyncClient( | |
| fidl::WireAsyncEventHandler<test::UnknownInteractionsProtocol>* handler = nullptr) { | |
| EXPECT_TRUE(client_end_.is_valid()); | |
| return fidl::WireClient<test::UnknownInteractionsProtocol>(std::move(client_end_), | |
| loop_->dispatcher(), handler); | |
| } | |
| private: | |
| std::optional<async::Loop> loop_; | |
| fidl::ClientEnd<test::UnknownInteractionsProtocol> client_end_; | |
| fidl::ServerEnd<test::UnknownInteractionsProtocol> server_end_; | |
| }; | |
| template <size_t N> | |
| std::array<uint8_t, N - sizeof(zx_txid_t)> ExcludeTxid(std::array<uint8_t, N> buf) { | |
| std::array<uint8_t, N - sizeof(zx_txid_t)> without_txid; | |
| std::memcpy(without_txid.data(), buf.data() + sizeof(zx_txid_t), without_txid.size()); | |
| return without_txid; | |
| } | |
| // 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; | |
| ReadResult() = delete; | |
| static ReadResult<N> ReadFromChannel(const zx::channel& channel) { | |
| ReadResult<N> result(channel); | |
| return result; | |
| } | |
| // Get the contents of the buffer excluding the transaction ID. | |
| std::array<uint8_t, N - sizeof(zx_txid_t)> buf_excluding_txid() { return ExcludeTxid(buf); } | |
| // Get the transaction id portion of the buffer. | |
| zx_txid_t txid() { | |
| zx_txid_t value; | |
| std::memcpy(&value, buf.data(), sizeof(zx_txid_t)); | |
| return value; | |
| } | |
| protected: | |
| // 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; | |
| uint32_t num_bytes; | |
| uint32_t num_handles; | |
| status = channel.read(/* flags= */ 0, buf.data(), /* handles= */ nullptr, N, | |
| /* num_handles= */ 0, &num_bytes, &num_handles); | |
| if (status == ZX_OK) { | |
| EXPECT_EQ(N, num_bytes); | |
| EXPECT_EQ(0u, num_handles); | |
| } | |
| } | |
| }; | |
| template <uint32_t N> | |
| struct TwoWayServerRequest : public ReadResult<N> { | |
| TwoWayServerRequest() = delete; | |
| static TwoWayServerRequest<N> ReadFromChannel(const zx::channel& channel) { | |
| TwoWayServerRequest<N> result(channel); | |
| return result; | |
| } | |
| // 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 <size_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()); | |
| ASSERT_EQ(ZX_OK, channel.write(/* flags= */ 0, reply_bytes.data(), static_cast<uint32_t>(M), | |
| /* handles= */ nullptr, /* num_handles= */ 0)); | |
| } | |
| protected: | |
| using ReadResult<N>::ReadResult; | |
| }; | |
| enum class ResultUnionTag : fidl_union_tag_t { | |
| kSuccess = 1, | |
| kDomainError = 2, | |
| kFrameworkError = 3, | |
| }; | |
| class InlineValue : public std::array<uint8_t, 4> { | |
| public: | |
| InlineValue(uint32_t value) { std::memcpy(data(), &value, sizeof(value)); } | |
| InlineValue(int32_t value) { std::memcpy(data(), &value, sizeof(value)); } | |
| }; | |
| // Make an array representing a message with a transaction header and body. | |
| template <typename FidlMethod> | |
| std::array<uint8_t, sizeof(fidl_message_header_t) + sizeof(fidl_union_t)> MakeMessage( | |
| zx_txid_t txid, fidl::MessageDynamicFlags dynamic_flags, ResultUnionTag result_union_tag, | |
| InlineValue inline_value) { | |
| fidl_message_header_t header{ | |
| .txid = txid, | |
| .at_rest_flags = {FIDL_MESSAGE_HEADER_AT_REST_FLAGS_0_USE_VERSION_V2, 0}, | |
| .dynamic_flags = dynamic_flags.value, | |
| .magic_number = kFidlWireFormatMagicNumberInitial, | |
| .ordinal = FidlMethod::kOrdinal, | |
| }; | |
| fidl_union_t body{ | |
| .tag = static_cast<std::underlying_type_t<ResultUnionTag>>(result_union_tag), | |
| .envelope = | |
| { | |
| .num_handles = 0, | |
| .flags = 1, | |
| }, | |
| }; | |
| std::memcpy(body.envelope.inline_value, inline_value.data(), sizeof(body.envelope.inline_value)); | |
| std::array<uint8_t, sizeof(fidl_message_header_t) + sizeof(fidl_union_t)> result; | |
| std::memcpy(result.data(), &header, sizeof(fidl_message_header_t)); | |
| std::memcpy(result.data() + sizeof(fidl_message_header_t), &body, sizeof(fidl_union_t)); | |
| return result; | |
| } | |
| // Make an array representing a message with a transaction header and body. | |
| // This version is for tests which don't care about the txid or want a zero | |
| // txid (e.g. one way interactions). | |
| template <typename FidlMethod> | |
| std::array<uint8_t, sizeof(fidl_message_header_t) + sizeof(fidl_union_t)> MakeMessage( | |
| fidl::MessageDynamicFlags dynamic_flags, ResultUnionTag result_union_tag, | |
| InlineValue inline_value) { | |
| return MakeMessage<FidlMethod>(0, dynamic_flags, result_union_tag, inline_value); | |
| } | |
| // Make an array representing a message with just a transaction header. | |
| template <typename FidlMethod> | |
| std::array<uint8_t, sizeof(fidl_message_header_t)> MakeMessage( | |
| zx_txid_t txid, fidl::MessageDynamicFlags dynamic_flags) { | |
| fidl_message_header_t header{ | |
| .txid = txid, | |
| .at_rest_flags = {FIDL_MESSAGE_HEADER_AT_REST_FLAGS_0_USE_VERSION_V2, 0}, | |
| .dynamic_flags = dynamic_flags.value, | |
| .magic_number = kFidlWireFormatMagicNumberInitial, | |
| .ordinal = FidlMethod::kOrdinal, | |
| }; | |
| std::array<uint8_t, sizeof(fidl_message_header_t)> result; | |
| std::memcpy(result.data(), &header, sizeof(fidl_message_header_t)); | |
| return result; | |
| } | |
| // Make an array representing a message with just a transaction header. | |
| // This version is for tests which don't care about the txid or want a zero | |
| // txid (e.g. one way interactions). | |
| template <typename FidlMethod> | |
| std::array<uint8_t, sizeof(fidl_message_header_t)> MakeMessage( | |
| fidl::MessageDynamicFlags dynamic_flags) { | |
| return MakeMessage<FidlMethod>(0, dynamic_flags); | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| /////////////////////////////////////////////////////////////////////////////// | |
| //// Client Side Tests | |
| /////////////////////////////////////////////////////////////////////////////// | |
| /////////////////////////////////////////////////////////////////////////////// | |
| /////////////////////////////////////////////////////////////////////////////// | |
| //// One-Way Methods - Async Client | |
| /////////////////////////////////////////////////////////////////////////////// | |
| TEST_F(UnknownInteractions, OneWayStrictAsyncSend) { | |
| auto client = AsyncClient(); | |
| auto server = TakeServerChannel(); | |
| auto result = client->StrictOneWay(); | |
| EXPECT_TRUE(result.ok()); | |
| auto received = ReadResult<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = MakeMessage<test::UnknownInteractionsProtocol::StrictOneWay>( | |
| fidl::MessageDynamicFlags::kStrictMethod); | |
| EXPECT_THAT(received.buf, ::testing::ContainerEq(expected)); | |
| } | |
| TEST_F(UnknownInteractions, OneWayFlexibleAsyncSend) { | |
| auto client = AsyncClient(); | |
| auto server = TakeServerChannel(); | |
| auto result = client->FlexibleOneWay(); | |
| EXPECT_TRUE(result.ok()); | |
| auto received = ReadResult<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = MakeMessage<test::UnknownInteractionsProtocol::FlexibleOneWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod); | |
| EXPECT_THAT(received.buf, ::testing::ContainerEq(expected)); | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| //// Two-Way Methods - Async Client | |
| /////////////////////////////////////////////////////////////////////////////// | |
| TEST_F(UnknownInteractions, TwoWayStrictAsyncSend) { | |
| auto client = AsyncClient(); | |
| auto server = TakeServerChannel(); | |
| client->StrictTwoWay().Then([](auto& response) { ASSERT_TRUE(response.ok()); }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::StrictTwoWay>( | |
| fidl::MessageDynamicFlags::kStrictMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::StrictTwoWay>( | |
| fidl::MessageDynamicFlags::kStrictMethod); | |
| received.reply(server, server_reply); | |
| loop().RunUntilIdle(); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayStrictErrAsyncSend) { | |
| auto client = AsyncClient(); | |
| auto server = TakeServerChannel(); | |
| client->StrictTwoWayErr().Then([](auto& response) { | |
| ASSERT_TRUE(response.ok()); | |
| EXPECT_TRUE(response.value().is_ok()); | |
| }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::StrictTwoWayErr>( | |
| fidl::MessageDynamicFlags::kStrictMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::StrictTwoWayErr>( | |
| fidl::MessageDynamicFlags::kStrictMethod, ResultUnionTag::kSuccess, 0); | |
| received.reply(server, server_reply); | |
| loop().RunUntilIdle(); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleFieldsAsyncSend) { | |
| auto client = AsyncClient(); | |
| auto server = TakeServerChannel(); | |
| client->FlexibleTwoWayFields().Then([](auto& response) { | |
| ASSERT_TRUE(response.ok()); | |
| EXPECT_EQ(32, response.value().some_field); | |
| }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayFields>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayFields>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kSuccess, 32); | |
| received.reply(server, server_reply); | |
| loop().RunUntilIdle(); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleFieldsAsyncSendUnknownResponse) { | |
| auto client = AsyncClient(); | |
| auto server = TakeServerChannel(); | |
| client->FlexibleTwoWayFields().Then([](auto& response) { | |
| ASSERT_FALSE(response.ok()); | |
| EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, response.status()); | |
| EXPECT_EQ(fidl::Reason::kUnknownMethod, response.reason()); | |
| }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayFields>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayFields>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kFrameworkError, | |
| ZX_ERR_NOT_SUPPORTED); | |
| received.reply(server, server_reply); | |
| loop().RunUntilIdle(); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleAsyncSend) { | |
| auto client = AsyncClient(); | |
| auto server = TakeServerChannel(); | |
| client->FlexibleTwoWay().Then([](auto& response) { EXPECT_TRUE(response.ok()); }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kSuccess, 0); | |
| received.reply(server, server_reply); | |
| loop().RunUntilIdle(); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleAsyncSendUnknownResponse) { | |
| auto client = AsyncClient(); | |
| auto server = TakeServerChannel(); | |
| client->FlexibleTwoWay().Then([](auto& response) { | |
| ASSERT_FALSE(response.ok()); | |
| EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, response.status()); | |
| EXPECT_EQ(fidl::Reason::kUnknownMethod, response.reason()); | |
| }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kFrameworkError, | |
| ZX_ERR_NOT_SUPPORTED); | |
| received.reply(server, server_reply); | |
| loop().RunUntilIdle(); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleAsyncSendOtherFrameworkError) { | |
| auto client = AsyncClient(); | |
| auto server = TakeServerChannel(); | |
| client->FlexibleTwoWay().Then([](auto& response) { | |
| ASSERT_FALSE(response.ok()); | |
| EXPECT_EQ(ZX_ERR_INVALID_ARGS, response.status()); | |
| EXPECT_EQ(fidl::Reason::kDecodeError, response.reason()); | |
| }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kFrameworkError, | |
| ZX_ERR_INVALID_ARGS); | |
| received.reply(server, server_reply); | |
| loop().RunUntilIdle(); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleAsyncSendOkFrameworkError) { | |
| auto client = AsyncClient(); | |
| auto server = TakeServerChannel(); | |
| client->FlexibleTwoWay().Then([](auto& response) { | |
| ASSERT_FALSE(response.ok()); | |
| EXPECT_EQ(ZX_ERR_INVALID_ARGS, response.status()); | |
| EXPECT_EQ(fidl::Reason::kDecodeError, response.reason()); | |
| }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kFrameworkError, ZX_OK); | |
| received.reply(server, server_reply); | |
| loop().RunUntilIdle(); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleAsyncSendErrorVariant) { | |
| auto client = AsyncClient(); | |
| auto server = TakeServerChannel(); | |
| client->FlexibleTwoWay().Then([](auto& response) { | |
| ASSERT_FALSE(response.ok()); | |
| EXPECT_EQ(fidl::Reason::kDecodeError, response.reason()); | |
| }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kDomainError, 0x100); | |
| received.reply(server, server_reply); | |
| loop().RunUntilIdle(); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleErrAsyncSend) { | |
| auto client = AsyncClient(); | |
| auto server = TakeServerChannel(); | |
| client->FlexibleTwoWayErr().Then([](auto& response) { | |
| ASSERT_TRUE(response.ok()); | |
| EXPECT_TRUE(response.value().is_ok()); | |
| }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kSuccess, 0); | |
| received.reply(server, server_reply); | |
| loop().RunUntilIdle(); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleErrAsyncSendUnknownResponse) { | |
| auto client = AsyncClient(); | |
| auto server = TakeServerChannel(); | |
| client->FlexibleTwoWayErr().Then([](auto& response) { | |
| ASSERT_FALSE(response.ok()); | |
| EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, response.status()); | |
| EXPECT_EQ(fidl::Reason::kUnknownMethod, response.reason()); | |
| }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kFrameworkError, | |
| ZX_ERR_NOT_SUPPORTED); | |
| received.reply(server, server_reply); | |
| loop().RunUntilIdle(); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleErrAsyncSendOtherFrameworkError) { | |
| auto client = AsyncClient(); | |
| auto server = TakeServerChannel(); | |
| client->FlexibleTwoWayErr().Then([](auto& response) { | |
| ASSERT_FALSE(response.ok()); | |
| EXPECT_EQ(ZX_ERR_INVALID_ARGS, response.status()); | |
| EXPECT_EQ(fidl::Reason::kDecodeError, response.reason()); | |
| }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kFrameworkError, | |
| ZX_ERR_ACCESS_DENIED); | |
| received.reply(server, server_reply); | |
| loop().RunUntilIdle(); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleErrAsyncSendErrorVariant) { | |
| auto client = AsyncClient(); | |
| auto server = TakeServerChannel(); | |
| client->FlexibleTwoWayErr().Then([](auto& response) { | |
| ASSERT_TRUE(response.ok()); | |
| ASSERT_TRUE(response.value().is_error()); | |
| EXPECT_EQ(0x100, response.value().error_value()); | |
| }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kDomainError, 0x100); | |
| received.reply(server, server_reply); | |
| loop().RunUntilIdle(); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleFieldsErrAsyncSend) { | |
| auto client = AsyncClient(); | |
| auto server = TakeServerChannel(); | |
| client->FlexibleTwoWayFieldsErr().Then([](auto& response) { | |
| ASSERT_TRUE(response.ok()); | |
| ASSERT_TRUE(response.value().is_ok()); | |
| EXPECT_EQ(32, response.value().value()->some_field); | |
| }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = | |
| ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kSuccess, 32); | |
| received.reply(server, server_reply); | |
| loop().RunUntilIdle(); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleFieldsErrAsyncSendUnknownResponse) { | |
| auto client = AsyncClient(); | |
| auto server = TakeServerChannel(); | |
| client->FlexibleTwoWayFieldsErr().Then([](auto& response) { | |
| ASSERT_FALSE(response.ok()); | |
| EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, response.status()); | |
| EXPECT_EQ(fidl::Reason::kUnknownMethod, response.reason()); | |
| }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = | |
| ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kFrameworkError, | |
| ZX_ERR_NOT_SUPPORTED); | |
| received.reply(server, server_reply); | |
| loop().RunUntilIdle(); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleFieldsErrAsyncSendErrorVariant) { | |
| auto client = AsyncClient(); | |
| auto server = TakeServerChannel(); | |
| client->FlexibleTwoWayFieldsErr().Then([](auto& response) { | |
| ASSERT_TRUE(response.ok()); | |
| ASSERT_TRUE(response.value().is_error()); | |
| EXPECT_EQ(0x100, response.value().error_value()); | |
| }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = | |
| ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kDomainError, 0x100); | |
| received.reply(server, server_reply); | |
| loop().RunUntilIdle(); | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| //// Events - Async Client | |
| /////////////////////////////////////////////////////////////////////////////// | |
| TEST_F(UnknownInteractions, ReceiveStrictEventAsync) { | |
| class EventHandler : public UnknownInteractionsEventHandlerBase { | |
| void StrictEvent() override { received_event = true; } | |
| public: | |
| bool received_event = false; | |
| }; | |
| EventHandler handler; | |
| auto client = AsyncClient(&handler); | |
| auto server = TakeServerChannel(); | |
| auto server_message = MakeMessage<::test::UnknownInteractionsProtocol::StrictEvent>( | |
| ::fidl::MessageDynamicFlags::kStrictMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| EXPECT_TRUE(handler.received_event); | |
| } | |
| TEST_F(UnknownInteractions, ReceiveStrictEventAsyncMismatchedStrictness) { | |
| class EventHandler : public UnknownInteractionsEventHandlerBase { | |
| void StrictEvent() override { received_event = true; } | |
| public: | |
| bool received_event = false; | |
| }; | |
| EventHandler handler; | |
| auto client = AsyncClient(&handler); | |
| auto server = TakeServerChannel(); | |
| auto server_message = MakeMessage<::test::UnknownInteractionsProtocol::StrictEvent>( | |
| ::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| EXPECT_TRUE(handler.received_event); | |
| } | |
| TEST_F(UnknownInteractions, ReceiveFlexibleEventAsync) { | |
| class EventHandler : public UnknownInteractionsEventHandlerBase { | |
| void FlexibleEvent() override { received_event = true; } | |
| public: | |
| bool received_event = false; | |
| }; | |
| EventHandler handler; | |
| auto client = AsyncClient(&handler); | |
| auto server = TakeServerChannel(); | |
| auto server_message = MakeMessage<::test::UnknownInteractionsProtocol::FlexibleEvent>( | |
| ::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| EXPECT_TRUE(handler.received_event); | |
| } | |
| TEST_F(UnknownInteractions, ReceiveFlexibleEventAsyncMismatchedStrictness) { | |
| class EventHandler : public UnknownInteractionsEventHandlerBase { | |
| void FlexibleEvent() override { received_event = true; } | |
| public: | |
| bool received_event = false; | |
| }; | |
| EventHandler handler; | |
| auto client = AsyncClient(&handler); | |
| auto server = TakeServerChannel(); | |
| auto server_message = MakeMessage<::test::UnknownInteractionsProtocol::FlexibleEvent>( | |
| ::fidl::MessageDynamicFlags::kStrictMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| EXPECT_TRUE(handler.received_event); | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| //// Unknown messages - Async Client | |
| /////////////////////////////////////////////////////////////////////////////// | |
| TEST_F(UnknownInteractions, UnknownServerSentTwoWayAsyncClient) { | |
| class EventHandler : public UnknownInteractionsEventHandlerBase {}; | |
| EventHandler handler; | |
| auto client = AsyncClient(&handler); | |
| auto server = TakeServerChannel(); | |
| auto server_message = | |
| MakeMessage<FakeUnknownMethod>(0xABCD, ::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_ERR_PEER_CLOSED, received.status); | |
| } | |
| TEST_F(UnknownInteractions, UnknownStrictEventAsync) { | |
| class EventHandler : public UnknownInteractionsEventHandlerBase {}; | |
| EventHandler handler; | |
| auto client = AsyncClient(&handler); | |
| auto server = TakeServerChannel(); | |
| auto server_message = MakeMessage<FakeUnknownMethod>(::fidl::MessageDynamicFlags::kStrictMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_ERR_PEER_CLOSED, received.status); | |
| } | |
| TEST_F(UnknownInteractions, UnknownFlexibleEventAsync) { | |
| class EventHandler : public UnknownInteractionsEventHandlerBase { | |
| void handle_unknown_event( | |
| ::fidl::UnknownEventMetadata<::test::UnknownInteractionsProtocol> metadata) override { | |
| received_event = true; | |
| ASSERT_EQ(FakeUnknownMethod::kOrdinal, metadata.event_ordinal); | |
| } | |
| public: | |
| bool received_event = false; | |
| }; | |
| EventHandler handler; | |
| auto client = AsyncClient(&handler); | |
| auto server = TakeServerChannel(); | |
| auto server_message = | |
| MakeMessage<FakeUnknownMethod>(::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| ASSERT_TRUE(handler.received_event); | |
| // Write again to check that the channel is still open. | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| } | |
| TEST_F(UnknownInteractions, UnknownStrictEventAsyncAjarProtocol) { | |
| class EventHandler | |
| : public ::fidl::WireAsyncEventHandler<::test::UnknownInteractionsAjarProtocol> { | |
| void handle_unknown_event( | |
| ::fidl::UnknownEventMetadata<::test::UnknownInteractionsAjarProtocol> metadata) override { | |
| ADD_FAILURE() << "Unexpected flexible unknown event"; | |
| } | |
| }; | |
| EventHandler handler; | |
| auto client = fidl::WireClient<::test::UnknownInteractionsAjarProtocol>( | |
| ::fidl::ClientEnd<::test::UnknownInteractionsAjarProtocol>(TakeClientChannel()), | |
| loop().dispatcher(), &handler); | |
| auto server = TakeServerChannel(); | |
| auto server_message = MakeMessage<FakeUnknownMethod>(::fidl::MessageDynamicFlags::kStrictMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_ERR_PEER_CLOSED, received.status); | |
| } | |
| TEST_F(UnknownInteractions, UnknownFlexibleEventAsyncAjarProtocol) { | |
| class EventHandler | |
| : public ::fidl::WireAsyncEventHandler<::test::UnknownInteractionsAjarProtocol> { | |
| void handle_unknown_event( | |
| ::fidl::UnknownEventMetadata<::test::UnknownInteractionsAjarProtocol> metadata) override { | |
| received_event = true; | |
| ASSERT_EQ(FakeUnknownMethod::kOrdinal, metadata.event_ordinal); | |
| } | |
| public: | |
| bool received_event = false; | |
| }; | |
| EventHandler handler; | |
| auto client = fidl::WireClient<::test::UnknownInteractionsAjarProtocol>( | |
| ::fidl::ClientEnd<::test::UnknownInteractionsAjarProtocol>(TakeClientChannel()), | |
| loop().dispatcher(), &handler); | |
| auto server = TakeServerChannel(); | |
| auto server_message = | |
| MakeMessage<FakeUnknownMethod>(::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| ASSERT_TRUE(handler.received_event); | |
| // Write again to check that the channel is still open. | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| } | |
| TEST_F(UnknownInteractions, UnknownStrictEventAsyncClosedProtocol) { | |
| class EventHandler | |
| : public ::fidl::WireAsyncEventHandler<::test::UnknownInteractionsClosedProtocol> {}; | |
| EventHandler handler; | |
| auto client = fidl::WireClient<::test::UnknownInteractionsClosedProtocol>( | |
| ::fidl::ClientEnd<::test::UnknownInteractionsClosedProtocol>(TakeClientChannel()), | |
| loop().dispatcher(), &handler); | |
| auto server = TakeServerChannel(); | |
| auto server_message = MakeMessage<FakeUnknownMethod>(::fidl::MessageDynamicFlags::kStrictMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_ERR_PEER_CLOSED, received.status); | |
| } | |
| TEST_F(UnknownInteractions, UnknownFlexibleEventAsyncClosedProtocol) { | |
| class EventHandler | |
| : public ::fidl::WireAsyncEventHandler<::test::UnknownInteractionsClosedProtocol> {}; | |
| EventHandler handler; | |
| auto client = fidl::WireClient<::test::UnknownInteractionsClosedProtocol>( | |
| ::fidl::ClientEnd<::test::UnknownInteractionsClosedProtocol>(TakeClientChannel()), | |
| loop().dispatcher(), &handler); | |
| auto server = TakeServerChannel(); | |
| auto server_message = | |
| MakeMessage<FakeUnknownMethod>(::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_ERR_PEER_CLOSED, received.status); | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| //// One-Way Methods - Sync Client | |
| /////////////////////////////////////////////////////////////////////////////// | |
| TEST_F(UnknownInteractions, OneWayStrictSyncSend) { | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| auto result = client->StrictOneWay(); | |
| EXPECT_TRUE(result.ok()); | |
| auto received = ReadResult<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = MakeMessage<test::UnknownInteractionsProtocol::StrictOneWay>( | |
| fidl::MessageDynamicFlags::kStrictMethod); | |
| EXPECT_THAT(received.buf, ::testing::ContainerEq(expected)); | |
| } | |
| TEST_F(UnknownInteractions, OneWayFlexibleSyncSend) { | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| auto result = client->FlexibleOneWay(); | |
| EXPECT_TRUE(result.ok()); | |
| auto received = ReadResult<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = MakeMessage<test::UnknownInteractionsProtocol::FlexibleOneWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod); | |
| EXPECT_THAT(received.buf, ::testing::ContainerEq(expected)); | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| //// Two-Way Methods - Sync Client | |
| /////////////////////////////////////////////////////////////////////////////// | |
| TEST_F(UnknownInteractions, TwoWayStrictSyncSend) { | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| fidl::Arena arena; | |
| auto response_fut = | |
| std::async([&client, &arena]() { return client.buffer(arena)->StrictTwoWay(); }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::StrictTwoWay>( | |
| fidl::MessageDynamicFlags::kStrictMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::StrictTwoWay>( | |
| fidl::MessageDynamicFlags::kStrictMethod); | |
| received.reply(server, server_reply); | |
| auto response = response_fut.get(); | |
| EXPECT_TRUE(response.ok()); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayStrictErrSyncSend) { | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| fidl::Arena arena; | |
| auto response_fut = | |
| std::async([&client, &arena]() { return client.buffer(arena)->StrictTwoWayErr(); }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::StrictTwoWayErr>( | |
| fidl::MessageDynamicFlags::kStrictMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::StrictTwoWayErr>( | |
| fidl::MessageDynamicFlags::kStrictMethod, ResultUnionTag::kSuccess, 0); | |
| received.reply(server, server_reply); | |
| auto response = response_fut.get(); | |
| ASSERT_TRUE(response.ok()); | |
| EXPECT_TRUE(response.value().is_ok()); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleSyncSend) { | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| fidl::Arena arena; | |
| auto response_fut = | |
| std::async([&client, &arena]() { return client.buffer(arena)->FlexibleTwoWay(); }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kSuccess, 0); | |
| received.reply(server, server_reply); | |
| auto response = response_fut.get(); | |
| EXPECT_TRUE(response.ok()); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleSyncSendUnknownResponse) { | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| fidl::Arena arena; | |
| auto response_fut = | |
| std::async([&client, &arena]() { return client.buffer(arena)->FlexibleTwoWay(); }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kFrameworkError, | |
| ZX_ERR_NOT_SUPPORTED); | |
| received.reply(server, server_reply); | |
| auto response = response_fut.get(); | |
| ASSERT_FALSE(response.ok()); | |
| EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, response.status()); | |
| EXPECT_EQ(fidl::Reason::kUnknownMethod, response.reason()); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleSyncSendOtherFrameworkError) { | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| fidl::Arena arena; | |
| auto response_fut = | |
| std::async([&client, &arena]() { return client.buffer(arena)->FlexibleTwoWay(); }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kFrameworkError, | |
| ZX_ERR_ACCESS_DENIED); | |
| received.reply(server, server_reply); | |
| auto response = response_fut.get(); | |
| ASSERT_FALSE(response.ok()); | |
| EXPECT_EQ(ZX_ERR_INVALID_ARGS, response.status()); | |
| EXPECT_EQ(fidl::Reason::kDecodeError, response.reason()); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleSyncSendOkFrameworkError) { | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| fidl::Arena arena; | |
| auto response_fut = | |
| std::async([&client, &arena]() { return client.buffer(arena)->FlexibleTwoWay(); }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kFrameworkError, ZX_OK); | |
| received.reply(server, server_reply); | |
| auto response = response_fut.get(); | |
| ASSERT_FALSE(response.ok()); | |
| EXPECT_EQ(ZX_ERR_INVALID_ARGS, response.status()); | |
| EXPECT_EQ(fidl::Reason::kDecodeError, response.reason()); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleSyncSendErrorVariant) { | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| fidl::Arena arena; | |
| auto response_fut = | |
| std::async([&client, &arena]() { return client.buffer(arena)->FlexibleTwoWay(); }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kDomainError, 0x100); | |
| received.reply(server, server_reply); | |
| auto response = response_fut.get(); | |
| ASSERT_FALSE(response.ok()); | |
| EXPECT_EQ(fidl::Reason::kDecodeError, response.reason()); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleFieldsSyncSend) { | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| fidl::Arena arena; | |
| auto response_fut = | |
| std::async([&client, &arena]() { return client.buffer(arena)->FlexibleTwoWayFields(); }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayFields>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayFields>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kSuccess, 32); | |
| received.reply(server, server_reply); | |
| auto response = response_fut.get(); | |
| ASSERT_TRUE(response.ok()); | |
| EXPECT_EQ(32, response.value().some_field); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleFieldsSyncSendUnknownResponse) { | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| fidl::Arena arena; | |
| auto response_fut = | |
| std::async([&client, &arena]() { return client.buffer(arena)->FlexibleTwoWayFields(); }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayFields>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayFields>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kFrameworkError, | |
| ZX_ERR_NOT_SUPPORTED); | |
| received.reply(server, server_reply); | |
| auto response = response_fut.get(); | |
| ASSERT_FALSE(response.ok()); | |
| EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, response.status()); | |
| EXPECT_EQ(fidl::Reason::kUnknownMethod, response.reason()); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleErrSyncSend) { | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| fidl::Arena arena; | |
| auto response_fut = | |
| std::async([&client, &arena]() { return client.buffer(arena)->FlexibleTwoWayErr(); }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kSuccess, 0); | |
| received.reply(server, server_reply); | |
| auto response = response_fut.get(); | |
| ASSERT_TRUE(response.ok()); | |
| EXPECT_TRUE(response.value().is_ok()); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleErrSyncSendUnknownResponse) { | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| fidl::Arena arena; | |
| auto response_fut = | |
| std::async([&client, &arena]() { return client.buffer(arena)->FlexibleTwoWayErr(); }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kFrameworkError, | |
| ZX_ERR_NOT_SUPPORTED); | |
| received.reply(server, server_reply); | |
| auto response = response_fut.get(); | |
| ASSERT_FALSE(response.ok()); | |
| EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, response.status()); | |
| EXPECT_EQ(fidl::Reason::kUnknownMethod, response.reason()); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleErrSyncSendOtherFrameworkError) { | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| fidl::Arena arena; | |
| auto response_fut = | |
| std::async([&client, &arena]() { return client.buffer(arena)->FlexibleTwoWayErr(); }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kFrameworkError, | |
| ZX_ERR_ACCESS_DENIED); | |
| received.reply(server, server_reply); | |
| auto response = response_fut.get(); | |
| ASSERT_FALSE(response.ok()); | |
| EXPECT_EQ(ZX_ERR_INVALID_ARGS, response.status()); | |
| EXPECT_EQ(fidl::Reason::kDecodeError, response.reason()); | |
| } | |
| TEST_F(UnknownInteractions, TwoWayFlexibleErrSyncSendErrorVariant) { | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| fidl::Arena arena; | |
| auto response_fut = | |
| std::async([&client, &arena]() { return client.buffer(arena)->FlexibleTwoWayErr(); }); | |
| auto received = TwoWayServerRequest<16>::ReadFromChannel(server); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = ExcludeTxid(MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod)); | |
| EXPECT_THAT(received.buf_excluding_txid(), ::testing::ContainerEq(expected)); | |
| EXPECT_NE(0u, received.txid()); | |
| auto server_reply = MakeMessage<test::UnknownInteractionsProtocol::FlexibleTwoWayErr>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kDomainError, 0x100); | |
| received.reply(server, server_reply); | |
| auto response = response_fut.get(); | |
| ASSERT_TRUE(response.ok()); | |
| ASSERT_TRUE(response.value().is_error()); | |
| EXPECT_EQ(0x100, response.value().error_value()); | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| //// Events - Sync Client | |
| /////////////////////////////////////////////////////////////////////////////// | |
| TEST_F(UnknownInteractions, ReceiveStrictEventSync) { | |
| class EventHandler : public UnknownInteractionsEventHandlerBase { | |
| void StrictEvent() override { received_event = true; } | |
| public: | |
| bool received_event = false; | |
| }; | |
| EventHandler handler; | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| auto server_message = MakeMessage<::test::UnknownInteractionsProtocol::StrictEvent>( | |
| ::fidl::MessageDynamicFlags::kStrictMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| EXPECT_TRUE(client.HandleOneEvent(handler).ok()); | |
| EXPECT_TRUE(handler.received_event); | |
| } | |
| TEST_F(UnknownInteractions, ReceiveStrictEventSyncMismatchedStrictness) { | |
| class EventHandler : public UnknownInteractionsEventHandlerBase { | |
| void StrictEvent() override { received_event = true; } | |
| public: | |
| bool received_event = false; | |
| }; | |
| EventHandler handler; | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| auto server_message = MakeMessage<::test::UnknownInteractionsProtocol::StrictEvent>( | |
| ::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| EXPECT_TRUE(client.HandleOneEvent(handler).ok()); | |
| EXPECT_TRUE(handler.received_event); | |
| } | |
| TEST_F(UnknownInteractions, ReceiveFlexibleEventSync) { | |
| class EventHandler : public UnknownInteractionsEventHandlerBase { | |
| void FlexibleEvent() override { received_event = true; } | |
| public: | |
| bool received_event = false; | |
| }; | |
| EventHandler handler; | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| auto server_message = MakeMessage<::test::UnknownInteractionsProtocol::FlexibleEvent>( | |
| ::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| EXPECT_TRUE(client.HandleOneEvent(handler).ok()); | |
| EXPECT_TRUE(handler.received_event); | |
| } | |
| TEST_F(UnknownInteractions, ReceiveFlexibleEventSyncMismatchedStrictness) { | |
| class EventHandler : public UnknownInteractionsEventHandlerBase { | |
| void FlexibleEvent() override { received_event = true; } | |
| public: | |
| bool received_event = false; | |
| }; | |
| EventHandler handler; | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| auto server_message = MakeMessage<::test::UnknownInteractionsProtocol::FlexibleEvent>( | |
| ::fidl::MessageDynamicFlags::kStrictMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| EXPECT_TRUE(client.HandleOneEvent(handler).ok()); | |
| EXPECT_TRUE(handler.received_event); | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| //// Unknown messages - Sync Client | |
| /////////////////////////////////////////////////////////////////////////////// | |
| TEST_F(UnknownInteractions, UnknownServerSentTwoWaySyncClient) { | |
| class EventHandler : public UnknownInteractionsEventHandlerBase {}; | |
| EventHandler handler; | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| auto server_message = | |
| MakeMessage<FakeUnknownMethod>(0xABCD, ::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| auto status = client.HandleOneEvent(handler); | |
| EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, status.status()); | |
| EXPECT_EQ(fidl::Reason::kUnexpectedMessage, status.reason()); | |
| } | |
| TEST_F(UnknownInteractions, UnknownStrictEventSync) { | |
| class EventHandler : public UnknownInteractionsEventHandlerBase {}; | |
| EventHandler handler; | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| auto server_message = MakeMessage<FakeUnknownMethod>(::fidl::MessageDynamicFlags::kStrictMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| auto status = client.HandleOneEvent(handler); | |
| EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, status.status()); | |
| EXPECT_EQ(fidl::Reason::kUnexpectedMessage, status.reason()); | |
| } | |
| TEST_F(UnknownInteractions, UnknownFlexibleEventSync) { | |
| class EventHandler : public UnknownInteractionsEventHandlerBase { | |
| void handle_unknown_event( | |
| ::fidl::UnknownEventMetadata<::test::UnknownInteractionsProtocol> metadata) override { | |
| received_event = true; | |
| ASSERT_EQ(FakeUnknownMethod::kOrdinal, metadata.event_ordinal); | |
| } | |
| public: | |
| bool received_event = false; | |
| }; | |
| EventHandler handler; | |
| auto client = SyncClient(); | |
| auto server = TakeServerChannel(); | |
| auto server_message = | |
| MakeMessage<FakeUnknownMethod>(::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| EXPECT_TRUE(client.HandleOneEvent(handler).ok()); | |
| ASSERT_TRUE(handler.received_event); | |
| // Write again to check that the channel is still open. | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| } | |
| TEST_F(UnknownInteractions, UnknownStrictEventSyncAjarProtocol) { | |
| class EventHandler | |
| : public ::fidl::WireSyncEventHandler<::test::UnknownInteractionsAjarProtocol> { | |
| void handle_unknown_event( | |
| ::fidl::UnknownEventMetadata<::test::UnknownInteractionsAjarProtocol> metadata) override { | |
| ADD_FAILURE() << "Unexpected flexible unknown event"; | |
| } | |
| }; | |
| EventHandler handler; | |
| auto client = fidl::WireSyncClient<::test::UnknownInteractionsAjarProtocol>( | |
| ::fidl::ClientEnd<::test::UnknownInteractionsAjarProtocol>(TakeClientChannel())); | |
| auto server = TakeServerChannel(); | |
| auto server_message = MakeMessage<FakeUnknownMethod>(::fidl::MessageDynamicFlags::kStrictMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| auto status = client.HandleOneEvent(handler); | |
| EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, status.status()); | |
| EXPECT_EQ(fidl::Reason::kUnexpectedMessage, status.reason()); | |
| } | |
| TEST_F(UnknownInteractions, UnknownFlexibleEventSyncAjarProtocol) { | |
| class EventHandler | |
| : public ::fidl::WireSyncEventHandler<::test::UnknownInteractionsAjarProtocol> { | |
| void handle_unknown_event( | |
| ::fidl::UnknownEventMetadata<::test::UnknownInteractionsAjarProtocol> metadata) override { | |
| received_event = true; | |
| ASSERT_EQ(FakeUnknownMethod::kOrdinal, metadata.event_ordinal); | |
| } | |
| public: | |
| bool received_event = false; | |
| }; | |
| EventHandler handler; | |
| auto client = fidl::WireSyncClient<::test::UnknownInteractionsAjarProtocol>( | |
| ::fidl::ClientEnd<::test::UnknownInteractionsAjarProtocol>(TakeClientChannel())); | |
| auto server = TakeServerChannel(); | |
| auto server_message = | |
| MakeMessage<FakeUnknownMethod>(::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| EXPECT_TRUE(client.HandleOneEvent(handler).ok()); | |
| ASSERT_TRUE(handler.received_event); | |
| // Write again to check that the channel is still open. | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| } | |
| TEST_F(UnknownInteractions, UnknownStrictEventSyncClosedProtocol) { | |
| class EventHandler | |
| : public ::fidl::WireSyncEventHandler<::test::UnknownInteractionsClosedProtocol> {}; | |
| EventHandler handler; | |
| auto client = fidl::WireSyncClient<::test::UnknownInteractionsClosedProtocol>( | |
| ::fidl::ClientEnd<::test::UnknownInteractionsClosedProtocol>(TakeClientChannel())); | |
| auto server = TakeServerChannel(); | |
| auto server_message = MakeMessage<FakeUnknownMethod>(::fidl::MessageDynamicFlags::kStrictMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| auto status = client.HandleOneEvent(handler); | |
| EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, status.status()); | |
| EXPECT_EQ(fidl::Reason::kUnexpectedMessage, status.reason()); | |
| } | |
| TEST_F(UnknownInteractions, UnknownFlexibleEventSyncClosedProtocol) { | |
| class EventHandler | |
| : public ::fidl::WireSyncEventHandler<::test::UnknownInteractionsClosedProtocol> {}; | |
| EventHandler handler; | |
| auto client = fidl::WireSyncClient<::test::UnknownInteractionsClosedProtocol>( | |
| ::fidl::ClientEnd<::test::UnknownInteractionsClosedProtocol>(TakeClientChannel())); | |
| auto server = TakeServerChannel(); | |
| auto server_message = | |
| MakeMessage<FakeUnknownMethod>(::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, server.write(0, &server_message, server_message.size(), nullptr, 0)); | |
| auto status = client.HandleOneEvent(handler); | |
| EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, status.status()); | |
| EXPECT_EQ(fidl::Reason::kUnexpectedMessage, status.reason()); | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| /////////////////////////////////////////////////////////////////////////////// | |
| //// Server Side Tests | |
| /////////////////////////////////////////////////////////////////////////////// | |
| /////////////////////////////////////////////////////////////////////////////// | |
| /////////////////////////////////////////////////////////////////////////////// | |
| //// Events - Server | |
| /////////////////////////////////////////////////////////////////////////////// | |
| TEST_F(UnknownInteractions, SendStrictEvent) { | |
| auto client = TakeClientChannel(); | |
| auto server = TakeServerEnd(); | |
| EXPECT_TRUE(fidl::WireSendEvent(server)->StrictEvent().ok()); | |
| auto received = ReadResult<16>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = MakeMessage<test::UnknownInteractionsProtocol::StrictEvent>( | |
| fidl::MessageDynamicFlags::kStrictMethod); | |
| EXPECT_THAT(received.buf, ::testing::ContainerEq(expected)); | |
| } | |
| TEST_F(UnknownInteractions, SendFlexibleEvent) { | |
| auto client = TakeClientChannel(); | |
| auto server = TakeServerEnd(); | |
| EXPECT_TRUE(fidl::WireSendEvent(server)->FlexibleEvent().ok()); | |
| auto received = ReadResult<16>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = MakeMessage<test::UnknownInteractionsProtocol::FlexibleEvent>( | |
| fidl::MessageDynamicFlags::kFlexibleMethod); | |
| EXPECT_THAT(received.buf, ::testing::ContainerEq(expected)); | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| //// Two-Way Methods - Server | |
| /////////////////////////////////////////////////////////////////////////////// | |
| TEST_F(UnknownInteractions, StrictTwoWayResponse) { | |
| auto client = TakeClientChannel(); | |
| class Server : public UnknownInteractionsServerBase { | |
| void StrictTwoWay(StrictTwoWayCompleter::Sync& completer) override { completer.Reply(); } | |
| }; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| auto client_request = MakeMessage<::test::UnknownInteractionsProtocol::StrictTwoWay>( | |
| 0xABCD, ::fidl::MessageDynamicFlags::kStrictMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<16>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = MakeMessage<::test::UnknownInteractionsProtocol::StrictTwoWay>( | |
| 0xABCD, ::fidl::MessageDynamicFlags::kStrictMethod); | |
| EXPECT_THAT(received.buf, ::testing::ContainerEq(expected)); | |
| } | |
| TEST_F(UnknownInteractions, StrictTwoWayResponseMismatchedStrictness) { | |
| auto client = TakeClientChannel(); | |
| class Server : public UnknownInteractionsServerBase { | |
| void StrictTwoWay(StrictTwoWayCompleter::Sync& completer) override { completer.Reply(); } | |
| }; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| // Server is not supposed to validate the flexible flag for known methods. | |
| auto client_request = MakeMessage<::test::UnknownInteractionsProtocol::StrictTwoWay>( | |
| 0xABCD, ::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<16>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = MakeMessage<::test::UnknownInteractionsProtocol::StrictTwoWay>( | |
| 0xABCD, ::fidl::MessageDynamicFlags::kStrictMethod); | |
| EXPECT_THAT(received.buf, ::testing::ContainerEq(expected)); | |
| } | |
| TEST_F(UnknownInteractions, StrictTwoWayErrResponse) { | |
| auto client = TakeClientChannel(); | |
| class Server : public UnknownInteractionsServerBase { | |
| void StrictTwoWayErr(StrictTwoWayErrCompleter::Sync& completer) override { | |
| completer.Reply(fit::ok()); | |
| } | |
| }; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| auto client_request = MakeMessage<::test::UnknownInteractionsProtocol::StrictTwoWayErr>( | |
| 0xABCD, ::fidl::MessageDynamicFlags::kStrictMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<32>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = MakeMessage<::test::UnknownInteractionsProtocol::StrictTwoWayErr>( | |
| 0xABCD, ::fidl::MessageDynamicFlags::kStrictMethod, ResultUnionTag::kSuccess, 0); | |
| EXPECT_THAT(received.buf, ::testing::ContainerEq(expected)); | |
| } | |
| TEST_F(UnknownInteractions, FlexibleTwoWayResponse) { | |
| auto client = TakeClientChannel(); | |
| class Server : public UnknownInteractionsServerBase { | |
| void FlexibleTwoWay(FlexibleTwoWayCompleter::Sync& completer) override { completer.Reply(); } | |
| }; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| auto client_request = MakeMessage<::test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| 0xABCD, ::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<32>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = MakeMessage<::test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| 0xABCD, ::fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kSuccess, 0); | |
| EXPECT_THAT(received.buf, ::testing::ContainerEq(expected)); | |
| } | |
| TEST_F(UnknownInteractions, FlexibleTwoWayResponseMismatchedStrictness) { | |
| auto client = TakeClientChannel(); | |
| class Server : public UnknownInteractionsServerBase { | |
| void FlexibleTwoWay(FlexibleTwoWayCompleter::Sync& completer) override { completer.Reply(); } | |
| }; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| // Server is not supposed to validate the flexible flag for known methods. | |
| auto client_request = MakeMessage<::test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| 0xABCD, ::fidl::MessageDynamicFlags::kStrictMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<32>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = MakeMessage<::test::UnknownInteractionsProtocol::FlexibleTwoWay>( | |
| 0xABCD, ::fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kSuccess, 0); | |
| EXPECT_THAT(received.buf, ::testing::ContainerEq(expected)); | |
| } | |
| TEST_F(UnknownInteractions, FlexibleTwoWayFieldsResponse) { | |
| auto client = TakeClientChannel(); | |
| class Server : public UnknownInteractionsServerBase { | |
| void FlexibleTwoWayFields(FlexibleTwoWayFieldsCompleter::Sync& completer) override { | |
| completer.Reply(42); | |
| } | |
| }; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| auto client_request = MakeMessage<::test::UnknownInteractionsProtocol::FlexibleTwoWayFields>( | |
| 0xABCD, ::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<32>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = MakeMessage<::test::UnknownInteractionsProtocol::FlexibleTwoWayFields>( | |
| 0xABCD, ::fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kSuccess, 42); | |
| EXPECT_THAT(received.buf, ::testing::ContainerEq(expected)); | |
| } | |
| TEST_F(UnknownInteractions, FlexibleTwoWayErrResponse) { | |
| auto client = TakeClientChannel(); | |
| class Server : public UnknownInteractionsServerBase { | |
| void FlexibleTwoWayErr(FlexibleTwoWayErrCompleter::Sync& completer) override { | |
| completer.Reply(fit::ok()); | |
| } | |
| }; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| auto client_request = MakeMessage<::test::UnknownInteractionsProtocol::FlexibleTwoWayErr>( | |
| 0xABCD, ::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<32>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = MakeMessage<::test::UnknownInteractionsProtocol::FlexibleTwoWayErr>( | |
| 0xABCD, ::fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kSuccess, 0); | |
| EXPECT_THAT(received.buf, ::testing::ContainerEq(expected)); | |
| } | |
| TEST_F(UnknownInteractions, FlexibleTwoWayErrResponseError) { | |
| auto client = TakeClientChannel(); | |
| class Server : public UnknownInteractionsServerBase { | |
| void FlexibleTwoWayErr(FlexibleTwoWayErrCompleter::Sync& completer) override { | |
| completer.Reply(fit::error(3203)); | |
| } | |
| }; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| auto client_request = MakeMessage<::test::UnknownInteractionsProtocol::FlexibleTwoWayErr>( | |
| 0xABCD, ::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<32>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = MakeMessage<::test::UnknownInteractionsProtocol::FlexibleTwoWayErr>( | |
| 0xABCD, ::fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kDomainError, 3203); | |
| EXPECT_THAT(received.buf, ::testing::ContainerEq(expected)); | |
| } | |
| TEST_F(UnknownInteractions, FlexibleTwoWayFieldsErrResponse) { | |
| auto client = TakeClientChannel(); | |
| class Server : public UnknownInteractionsServerBase { | |
| void FlexibleTwoWayFieldsErr(FlexibleTwoWayFieldsErrCompleter::Sync& completer) override { | |
| ::test::wire::UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse reply{ | |
| .some_field = 42, | |
| }; | |
| completer.Reply(::fit::ok(&reply)); | |
| } | |
| }; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| auto client_request = MakeMessage<::test::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr>( | |
| 0xABCD, ::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<32>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = MakeMessage<::test::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr>( | |
| 0xABCD, ::fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kSuccess, 42); | |
| EXPECT_THAT(received.buf, ::testing::ContainerEq(expected)); | |
| } | |
| TEST_F(UnknownInteractions, FlexibleTwoWayFieldsErrResponseError) { | |
| auto client = TakeClientChannel(); | |
| class Server : public UnknownInteractionsServerBase { | |
| void FlexibleTwoWayFieldsErr(FlexibleTwoWayFieldsErrCompleter::Sync& completer) override { | |
| completer.Reply(fit::error(3203)); | |
| } | |
| }; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| auto client_request = MakeMessage<::test::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr>( | |
| 0xABCD, ::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<32>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = MakeMessage<::test::UnknownInteractionsProtocol::FlexibleTwoWayFieldsErr>( | |
| 0xABCD, ::fidl::MessageDynamicFlags::kFlexibleMethod, ResultUnionTag::kDomainError, 3203); | |
| EXPECT_THAT(received.buf, ::testing::ContainerEq(expected)); | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| //// Unknown messages - Server | |
| /////////////////////////////////////////////////////////////////////////////// | |
| TEST_F(UnknownInteractions, UnknownStrictOneWay) { | |
| auto client = TakeClientChannel(); | |
| class Server : public UnknownInteractionsServerBase {}; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| auto client_request = | |
| MakeMessage<FakeUnknownMethod>(0, ::fidl::MessageDynamicFlags::kStrictMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<16>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_ERR_PEER_CLOSED, received.status); | |
| } | |
| TEST_F(UnknownInteractions, UnknownFlexibleOneWay) { | |
| auto client = TakeClientChannel(); | |
| class Server : public UnknownInteractionsServerBase { | |
| public: | |
| bool ran_unknown_interaction_handler = false; | |
| void handle_unknown_method( | |
| ::fidl::UnknownMethodMetadata<::test::UnknownInteractionsProtocol> metadata, | |
| ::fidl::UnknownMethodCompleter::Sync& completer) override { | |
| ran_unknown_interaction_handler = true; | |
| EXPECT_EQ(FakeUnknownMethod::kOrdinal, metadata.method_ordinal); | |
| EXPECT_EQ(::fidl::UnknownMethodType::kOneWay, metadata.unknown_method_type); | |
| } | |
| }; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| auto client_request = | |
| MakeMessage<FakeUnknownMethod>(0, ::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| EXPECT_TRUE(server.ran_unknown_interaction_handler); | |
| EXPECT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| } | |
| TEST_F(UnknownInteractions, UnknownStrictTwoWay) { | |
| auto client = TakeClientChannel(); | |
| class Server : public UnknownInteractionsServerBase {}; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| auto client_request = | |
| MakeMessage<FakeUnknownMethod>(0xABCD, ::fidl::MessageDynamicFlags::kStrictMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<16>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_ERR_PEER_CLOSED, received.status); | |
| } | |
| TEST_F(UnknownInteractions, UnknownFlexibleTwoWay) { | |
| auto client = TakeClientChannel(); | |
| class Server : public UnknownInteractionsServerBase { | |
| public: | |
| bool ran_unknown_interaction_handler = false; | |
| void handle_unknown_method( | |
| ::fidl::UnknownMethodMetadata<::test::UnknownInteractionsProtocol> metadata, | |
| ::fidl::UnknownMethodCompleter::Sync& completer) override { | |
| ran_unknown_interaction_handler = true; | |
| EXPECT_EQ(FakeUnknownMethod::kOrdinal, metadata.method_ordinal); | |
| EXPECT_EQ(::fidl::UnknownMethodType::kTwoWay, metadata.unknown_method_type); | |
| } | |
| }; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| auto client_request = | |
| MakeMessage<FakeUnknownMethod>(0xABCD, ::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| EXPECT_TRUE(server.ran_unknown_interaction_handler); | |
| auto received = ReadResult<32>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_OK, received.status); | |
| auto expected = | |
| MakeMessage<FakeUnknownMethod>(0xABCD, ::fidl::MessageDynamicFlags::kFlexibleMethod, | |
| ResultUnionTag::kFrameworkError, ZX_ERR_NOT_SUPPORTED); | |
| EXPECT_THAT(received.buf, ::testing::ContainerEq(expected)); | |
| } | |
| TEST_F(UnknownInteractions, UnknownStrictOneWayAjarProtocol) { | |
| auto client = TakeClientChannel(); | |
| class Server : public ::fidl::WireServer<::test::UnknownInteractionsAjarProtocol> { | |
| void handle_unknown_method( | |
| ::fidl::UnknownMethodMetadata<::test::UnknownInteractionsAjarProtocol> metadata, | |
| ::fidl::UnknownMethodCompleter::Sync& completer) override { | |
| ADD_FAILURE() << "Unexpected flexible unknown interaction"; | |
| } | |
| }; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| auto client_request = | |
| MakeMessage<FakeUnknownMethod>(0, ::fidl::MessageDynamicFlags::kStrictMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<16>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_ERR_PEER_CLOSED, received.status); | |
| } | |
| TEST_F(UnknownInteractions, UnknownFlexibleOneWayAjarProtocol) { | |
| auto client = TakeClientChannel(); | |
| class Server : public ::fidl::WireServer<::test::UnknownInteractionsAjarProtocol> { | |
| public: | |
| bool ran_unknown_interaction_handler = false; | |
| void handle_unknown_method( | |
| ::fidl::UnknownMethodMetadata<::test::UnknownInteractionsAjarProtocol> metadata, | |
| ::fidl::UnknownMethodCompleter::Sync& completer) override { | |
| ran_unknown_interaction_handler = true; | |
| EXPECT_EQ(FakeUnknownMethod::kOrdinal, metadata.method_ordinal); | |
| } | |
| }; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| auto client_request = | |
| MakeMessage<FakeUnknownMethod>(0, ::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| EXPECT_TRUE(server.ran_unknown_interaction_handler); | |
| EXPECT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| } | |
| TEST_F(UnknownInteractions, UnknownStrictTwoWayAjarProtocol) { | |
| auto client = TakeClientChannel(); | |
| class Server : public ::fidl::WireServer<::test::UnknownInteractionsAjarProtocol> { | |
| void handle_unknown_method( | |
| ::fidl::UnknownMethodMetadata<::test::UnknownInteractionsAjarProtocol> metadata, | |
| ::fidl::UnknownMethodCompleter::Sync& completer) override { | |
| ADD_FAILURE() << "Unexpected flexible unknown interaction"; | |
| } | |
| }; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| auto client_request = | |
| MakeMessage<FakeUnknownMethod>(0xABCD, ::fidl::MessageDynamicFlags::kStrictMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<16>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_ERR_PEER_CLOSED, received.status); | |
| } | |
| TEST_F(UnknownInteractions, UnknownFlexibleTwoWayAjarProtocol) { | |
| auto client = TakeClientChannel(); | |
| class Server : public ::fidl::WireServer<::test::UnknownInteractionsAjarProtocol> { | |
| void handle_unknown_method( | |
| ::fidl::UnknownMethodMetadata<::test::UnknownInteractionsAjarProtocol> metadata, | |
| ::fidl::UnknownMethodCompleter::Sync& completer) override { | |
| ADD_FAILURE() << "Unexpected flexible unknown interaction"; | |
| } | |
| }; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| auto client_request = | |
| MakeMessage<FakeUnknownMethod>(0xABCD, ::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<16>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_ERR_PEER_CLOSED, received.status); | |
| } | |
| TEST_F(UnknownInteractions, UnknownStrictOneWayClosedProtocol) { | |
| auto client = TakeClientChannel(); | |
| class Server : public ::fidl::WireServer<::test::UnknownInteractionsClosedProtocol> {}; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| auto client_request = | |
| MakeMessage<FakeUnknownMethod>(0, ::fidl::MessageDynamicFlags::kStrictMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<16>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_ERR_PEER_CLOSED, received.status); | |
| } | |
| TEST_F(UnknownInteractions, UnknownFlexibleOneWayClosedProtocol) { | |
| auto client = TakeClientChannel(); | |
| class Server : public ::fidl::WireServer<::test::UnknownInteractionsClosedProtocol> {}; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| auto client_request = | |
| MakeMessage<FakeUnknownMethod>(0, ::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<16>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_ERR_PEER_CLOSED, received.status); | |
| } | |
| TEST_F(UnknownInteractions, UnknownStrictTwoWayClosedProtocol) { | |
| auto client = TakeClientChannel(); | |
| class Server : public ::fidl::WireServer<::test::UnknownInteractionsClosedProtocol> {}; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| auto client_request = | |
| MakeMessage<FakeUnknownMethod>(0xABCD, ::fidl::MessageDynamicFlags::kStrictMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<16>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_ERR_PEER_CLOSED, received.status); | |
| } | |
| TEST_F(UnknownInteractions, UnknownFlexibleTwoWayClosedProtocol) { | |
| auto client = TakeClientChannel(); | |
| class Server : public ::fidl::WireServer<::test::UnknownInteractionsClosedProtocol> {}; | |
| Server server; | |
| auto server_binding = BindServer(&server); | |
| auto client_request = | |
| MakeMessage<FakeUnknownMethod>(0xABCD, ::fidl::MessageDynamicFlags::kFlexibleMethod); | |
| ASSERT_EQ(ZX_OK, client.write(0, &client_request, client_request.size(), nullptr, 0)); | |
| loop().RunUntilIdle(); | |
| auto received = ReadResult<16>::ReadFromChannel(client); | |
| EXPECT_EQ(ZX_ERR_PEER_CLOSED, received.status); | |
| } | |
| } // namespace |