mirror of https://github.com/grpc/grpc.git
Reland: Import binder transport tests (#27138)
* Import binder transport tests * Fix copybara import errors * Add testonly labelspull/27145/head
Ta-Wei Tu
3 years ago
committed by
GitHub
parent
ecc07b6979
commit
ab57f03b30
24 changed files with 4006 additions and 58 deletions
@ -1,38 +0,0 @@ |
||||
//
|
||||
// Copyright 2021 gRPC authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
|
||||
#include <grpc/grpc.h> |
||||
#include <grpc/support/log.h> |
||||
#include <gtest/gtest.h> |
||||
|
||||
#include "test/core/util/test_config.h" |
||||
|
||||
namespace grpc_core { |
||||
namespace testing { |
||||
namespace { |
||||
TEST(SmokeTest, Empty) { gpr_log(GPR_INFO, __func__); } |
||||
} // namespace
|
||||
} // namespace testing
|
||||
} // namespace grpc_core
|
||||
|
||||
int main(int argc, char** argv) { |
||||
::testing::InitGoogleTest(&argc, argv); |
||||
grpc::testing::TestEnvironment env(argc, argv); |
||||
grpc_init(); |
||||
int ret = RUN_ALL_TESTS(); |
||||
grpc_shutdown(); |
||||
return ret; |
||||
} |
||||
@ -0,0 +1,742 @@ |
||||
// Copyright 2021 gRPC authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// Unit-tests for grpc_binder_transport
|
||||
//
|
||||
// Verify that a calls to the perform_stream_op of grpc_binder_transport
|
||||
// transform into the correct sequence of binder transactions.
|
||||
#include "src/core/ext/transport/binder/transport/binder_transport.h" |
||||
|
||||
#include <grpc/grpc.h> |
||||
#include <gtest/gtest.h> |
||||
#include <memory> |
||||
#include <string> |
||||
#include <vector> |
||||
|
||||
#include "absl/memory/memory.h" |
||||
#include "absl/strings/match.h" |
||||
#include "src/core/ext/transport/binder/transport/binder_stream.h" |
||||
#include "test/core/transport/binder/mock_objects.h" |
||||
#include "test/core/util/test_config.h" |
||||
|
||||
namespace grpc_binder { |
||||
namespace { |
||||
|
||||
using ::testing::Expectation; |
||||
using ::testing::NiceMock; |
||||
using ::testing::Return; |
||||
|
||||
class BinderTransportTest : public ::testing::Test { |
||||
public: |
||||
BinderTransportTest() |
||||
: arena_(grpc_core::Arena::Create(/* initial_size = */ 1)), |
||||
transport_(grpc_create_binder_transport_client( |
||||
absl::make_unique<NiceMock<MockBinder>>())) { |
||||
auto* gbt = reinterpret_cast<grpc_binder_transport*>(transport_); |
||||
gbt->wire_writer = absl::make_unique<MockWireWriter>(); |
||||
GRPC_STREAM_REF_INIT(&ref_, 1, nullptr, nullptr, "phony ref"); |
||||
} |
||||
|
||||
~BinderTransportTest() override { |
||||
auto* gbt = reinterpret_cast<grpc_binder_transport*>(transport_); |
||||
delete gbt; |
||||
for (grpc_binder_stream* gbs : stream_buffer_) { |
||||
gpr_free(gbs); |
||||
} |
||||
arena_->Destroy(); |
||||
} |
||||
|
||||
void PerformStreamOp(grpc_binder_stream* gbs, |
||||
grpc_transport_stream_op_batch* op) { |
||||
grpc_transport_perform_stream_op(transport_, |
||||
reinterpret_cast<grpc_stream*>(gbs), op); |
||||
} |
||||
|
||||
grpc_binder_transport* GetBinderTransport() { |
||||
return reinterpret_cast<grpc_binder_transport*>(transport_); |
||||
} |
||||
|
||||
grpc_binder_stream* InitNewBinderStream() { |
||||
grpc_binder_stream* gbs = static_cast<grpc_binder_stream*>( |
||||
gpr_malloc(grpc_transport_stream_size(transport_))); |
||||
grpc_transport_init_stream(transport_, reinterpret_cast<grpc_stream*>(gbs), |
||||
&ref_, nullptr, arena_); |
||||
stream_buffer_.push_back(gbs); |
||||
return gbs; |
||||
} |
||||
|
||||
MockWireWriter& GetWireWriter() { |
||||
return *reinterpret_cast<MockWireWriter*>( |
||||
GetBinderTransport()->wire_writer.get()); |
||||
} |
||||
|
||||
static void SetUpTestSuite() { grpc_init(); } |
||||
static void TearDownTestSuite() { grpc_shutdown(); } |
||||
|
||||
protected: |
||||
grpc_core::Arena* arena_; |
||||
grpc_transport* transport_; |
||||
grpc_stream_refcount ref_; |
||||
std::vector<grpc_binder_stream*> stream_buffer_; |
||||
}; |
||||
|
||||
void MockCallback(void* arg, grpc_error_handle error); |
||||
|
||||
class MockGrpcClosure { |
||||
public: |
||||
MockGrpcClosure() { |
||||
GRPC_CLOSURE_INIT(&closure_, MockCallback, this, nullptr); |
||||
} |
||||
|
||||
grpc_closure* GetGrpcClosure() { return &closure_; } |
||||
MOCK_METHOD(void, Callback, (grpc_error_handle), ()); |
||||
|
||||
private: |
||||
grpc_closure closure_; |
||||
}; |
||||
|
||||
void MockCallback(void* arg, grpc_error_handle error) { |
||||
MockGrpcClosure* mock_closure = static_cast<MockGrpcClosure*>(arg); |
||||
mock_closure->Callback(error); |
||||
} |
||||
|
||||
// Matches with transactions having the desired flag, method_ref,
|
||||
// initial_metadata, and message_data.
|
||||
MATCHER_P4(TransactionMatches, flag, method_ref, initial_metadata, message_data, |
||||
"") { |
||||
if (arg.GetFlags() != flag) return false; |
||||
if (flag & kFlagPrefix) { |
||||
if (arg.GetMethodRef() != method_ref) return false; |
||||
if (arg.GetPrefixMetadata() != initial_metadata) return false; |
||||
} |
||||
if (flag & kFlagMessageData) { |
||||
if (arg.GetMessageData() != message_data) return false; |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
// Matches with grpc_error having error message containing |msg|.
|
||||
MATCHER_P(GrpcErrorMessageContains, msg, "") { |
||||
return absl::StrContains(grpc_error_std_string(arg), msg); |
||||
} |
||||
|
||||
// Verify that the lower-level metadata has the same content as the gRPC
|
||||
// metadata.
|
||||
void VerifyMetadataEqual(const Metadata& md, grpc_metadata_batch grpc_md) { |
||||
grpc_linked_mdelem* elm = grpc_md.list.head; |
||||
for (size_t i = 0; i < md.size(); ++i) { |
||||
ASSERT_NE(elm, nullptr); |
||||
EXPECT_EQ(grpc_core::StringViewFromSlice(GRPC_MDKEY(elm->md)), md[i].first); |
||||
EXPECT_EQ(grpc_core::StringViewFromSlice(GRPC_MDVALUE(elm->md)), |
||||
md[i].second); |
||||
elm = elm->next; |
||||
} |
||||
EXPECT_EQ(elm, nullptr); |
||||
} |
||||
|
||||
// RAII helper classes for constructing gRPC metadata and receiving callbacks.
|
||||
struct MakeSendInitialMetadata { |
||||
MakeSendInitialMetadata(const Metadata& initial_metadata, |
||||
const std::string& method_ref, |
||||
grpc_transport_stream_op_batch* op) |
||||
: storage(initial_metadata.size()) { |
||||
grpc_metadata_batch_init(&grpc_initial_metadata); |
||||
size_t i = 0; |
||||
for (const auto& md : initial_metadata) { |
||||
const std::string& key = md.first; |
||||
const std::string& value = md.second; |
||||
EXPECT_EQ(grpc_metadata_batch_add_tail( |
||||
&grpc_initial_metadata, &storage[i], |
||||
grpc_mdelem_from_slices(grpc_slice_from_cpp_string(key), |
||||
grpc_slice_from_cpp_string(value))), |
||||
GRPC_ERROR_NONE); |
||||
i++; |
||||
} |
||||
if (!method_ref.empty()) { |
||||
EXPECT_EQ( |
||||
grpc_metadata_batch_add_tail( |
||||
&grpc_initial_metadata, &method_ref_storage, |
||||
grpc_mdelem_from_slices(GRPC_MDSTR_PATH, |
||||
grpc_slice_from_cpp_string(method_ref))), |
||||
GRPC_ERROR_NONE); |
||||
} |
||||
op->send_initial_metadata = true; |
||||
op->payload->send_initial_metadata.send_initial_metadata = |
||||
&grpc_initial_metadata; |
||||
} |
||||
~MakeSendInitialMetadata() { |
||||
grpc_metadata_batch_destroy(&grpc_initial_metadata); |
||||
} |
||||
|
||||
std::vector<grpc_linked_mdelem> storage; |
||||
grpc_linked_mdelem method_ref_storage; |
||||
grpc_metadata_batch grpc_initial_metadata{}; |
||||
}; |
||||
|
||||
struct MakeSendMessage { |
||||
MakeSendMessage(const std::string& message, |
||||
grpc_transport_stream_op_batch* op) { |
||||
grpc_slice_buffer send_buffer; |
||||
grpc_slice_buffer_init(&send_buffer); |
||||
grpc_slice send_slice = grpc_slice_from_cpp_string(message); |
||||
grpc_slice_buffer_add(&send_buffer, send_slice); |
||||
|
||||
send_stream.Init(&send_buffer, 0); |
||||
grpc_slice_buffer_destroy(&send_buffer); |
||||
|
||||
op->send_message = true; |
||||
op->payload->send_message.send_message.reset(send_stream.get()); |
||||
} |
||||
|
||||
grpc_core::ManualConstructor<grpc_core::SliceBufferByteStream> send_stream; |
||||
}; |
||||
|
||||
struct MakeSendTrailingMetadata { |
||||
explicit MakeSendTrailingMetadata(const Metadata& trailing_metadata, |
||||
grpc_transport_stream_op_batch* op) { |
||||
EXPECT_TRUE(trailing_metadata.empty()); |
||||
grpc_metadata_batch_init(&grpc_trailing_metadata); |
||||
|
||||
op->send_trailing_metadata = true; |
||||
op->payload->send_trailing_metadata.send_trailing_metadata = |
||||
&grpc_trailing_metadata; |
||||
} |
||||
|
||||
grpc_metadata_batch grpc_trailing_metadata{}; |
||||
}; |
||||
|
||||
struct MakeRecvInitialMetadata { |
||||
explicit MakeRecvInitialMetadata(grpc_transport_stream_op_batch* op, |
||||
Expectation* call_before = nullptr) { |
||||
grpc_metadata_batch_init(&grpc_initial_metadata); |
||||
op->recv_initial_metadata = true; |
||||
op->payload->recv_initial_metadata.recv_initial_metadata = |
||||
&grpc_initial_metadata; |
||||
op->payload->recv_initial_metadata.recv_initial_metadata_ready = |
||||
ready.GetGrpcClosure(); |
||||
if (call_before) { |
||||
EXPECT_CALL(ready, Callback).After(*call_before); |
||||
} else { |
||||
EXPECT_CALL(ready, Callback); |
||||
} |
||||
} |
||||
|
||||
~MakeRecvInitialMetadata() { |
||||
grpc_metadata_batch_destroy(&grpc_initial_metadata); |
||||
} |
||||
|
||||
MockGrpcClosure ready; |
||||
grpc_metadata_batch grpc_initial_metadata; |
||||
}; |
||||
|
||||
struct MakeRecvMessage { |
||||
explicit MakeRecvMessage(grpc_transport_stream_op_batch* op, |
||||
Expectation* call_before = nullptr) { |
||||
op->recv_message = true; |
||||
op->payload->recv_message.recv_message = &grpc_message; |
||||
op->payload->recv_message.recv_message_ready = ready.GetGrpcClosure(); |
||||
if (call_before) { |
||||
EXPECT_CALL(ready, Callback).After(*call_before); |
||||
} else { |
||||
EXPECT_CALL(ready, Callback); |
||||
} |
||||
} |
||||
|
||||
MockGrpcClosure ready; |
||||
grpc_core::OrphanablePtr<grpc_core::ByteStream> grpc_message; |
||||
}; |
||||
|
||||
struct MakeRecvTrailingMetadata { |
||||
explicit MakeRecvTrailingMetadata(grpc_transport_stream_op_batch* op, |
||||
Expectation* call_before = nullptr) { |
||||
grpc_metadata_batch_init(&grpc_trailing_metadata); |
||||
op->recv_trailing_metadata = true; |
||||
op->payload->recv_trailing_metadata.recv_trailing_metadata = |
||||
&grpc_trailing_metadata; |
||||
op->payload->recv_trailing_metadata.recv_trailing_metadata_ready = |
||||
ready.GetGrpcClosure(); |
||||
if (call_before) { |
||||
EXPECT_CALL(ready, Callback).After(*call_before); |
||||
} else { |
||||
EXPECT_CALL(ready, Callback); |
||||
} |
||||
} |
||||
|
||||
~MakeRecvTrailingMetadata() { |
||||
grpc_metadata_batch_destroy(&grpc_trailing_metadata); |
||||
} |
||||
|
||||
MockGrpcClosure ready; |
||||
grpc_metadata_batch grpc_trailing_metadata; |
||||
}; |
||||
|
||||
const Metadata kDefaultMetadata = { |
||||
{"", ""}, |
||||
{"", "value"}, |
||||
{"key", ""}, |
||||
{"key", "value"}, |
||||
}; |
||||
|
||||
constexpr char kDefaultMethodRef[] = "/some/path"; |
||||
constexpr char kDefaultMessage[] = "binder transport message"; |
||||
constexpr int kDefaultStatus = 0x1234; |
||||
|
||||
Metadata AppendMethodRef(const Metadata& md, const std::string& method_ref) { |
||||
Metadata result = md; |
||||
result.emplace_back(":path", method_ref); |
||||
return result; |
||||
} |
||||
|
||||
Metadata AppendStatus(const Metadata& md, int status) { |
||||
Metadata result = md; |
||||
result.emplace_back("grpc-status", std::to_string(status)); |
||||
return result; |
||||
} |
||||
|
||||
} // namespace
|
||||
|
||||
TEST_F(BinderTransportTest, CreateBinderTransport) { |
||||
EXPECT_NE(transport_, nullptr); |
||||
} |
||||
|
||||
TEST_F(BinderTransportTest, TransactionIdIncrement) { |
||||
grpc_binder_stream* gbs0 = InitNewBinderStream(); |
||||
EXPECT_EQ(gbs0->t, GetBinderTransport()); |
||||
EXPECT_EQ(gbs0->tx_code, kFirstCallId); |
||||
EXPECT_EQ(gbs0->seq, 0); |
||||
grpc_binder_stream* gbs1 = InitNewBinderStream(); |
||||
EXPECT_EQ(gbs1->t, GetBinderTransport()); |
||||
EXPECT_EQ(gbs1->tx_code, kFirstCallId + 1); |
||||
EXPECT_EQ(gbs1->seq, 0); |
||||
grpc_binder_stream* gbs2 = InitNewBinderStream(); |
||||
EXPECT_EQ(gbs2->t, GetBinderTransport()); |
||||
EXPECT_EQ(gbs2->tx_code, kFirstCallId + 2); |
||||
EXPECT_EQ(gbs2->seq, 0); |
||||
} |
||||
|
||||
TEST_F(BinderTransportTest, SeqNumIncrement) { |
||||
grpc_binder_stream* gbs = InitNewBinderStream(); |
||||
EXPECT_EQ(gbs->t, GetBinderTransport()); |
||||
EXPECT_EQ(gbs->tx_code, kFirstCallId); |
||||
// A simple batch that contains only "send_initial_metadata"
|
||||
grpc_transport_stream_op_batch op{}; |
||||
grpc_transport_stream_op_batch_payload payload(nullptr); |
||||
op.payload = &payload; |
||||
MakeSendInitialMetadata send_initial_metadata(kDefaultMetadata, "", &op); |
||||
EXPECT_EQ(gbs->seq, 0); |
||||
PerformStreamOp(gbs, &op); |
||||
EXPECT_EQ(gbs->tx_code, kFirstCallId); |
||||
EXPECT_EQ(gbs->seq, 1); |
||||
PerformStreamOp(gbs, &op); |
||||
EXPECT_EQ(gbs->tx_code, kFirstCallId); |
||||
EXPECT_EQ(gbs->seq, 2); |
||||
} |
||||
|
||||
TEST_F(BinderTransportTest, SeqNumNotIncrementWithoutSend) { |
||||
{ |
||||
grpc_binder_stream* gbs = InitNewBinderStream(); |
||||
EXPECT_EQ(gbs->t, GetBinderTransport()); |
||||
EXPECT_EQ(gbs->tx_code, kFirstCallId); |
||||
// No-op batch.
|
||||
grpc_transport_stream_op_batch op{}; |
||||
EXPECT_EQ(gbs->seq, 0); |
||||
PerformStreamOp(gbs, &op); |
||||
EXPECT_EQ(gbs->tx_code, kFirstCallId); |
||||
EXPECT_EQ(gbs->seq, 0); |
||||
} |
||||
{ |
||||
grpc_core::ExecCtx exec_ctx; |
||||
grpc_binder_stream* gbs = InitNewBinderStream(); |
||||
EXPECT_EQ(gbs->t, GetBinderTransport()); |
||||
EXPECT_EQ(gbs->tx_code, kFirstCallId + 1); |
||||
// Batch with only receiving operations.
|
||||
grpc_transport_stream_op_batch op{}; |
||||
grpc_transport_stream_op_batch_payload payload(nullptr); |
||||
op.payload = &payload; |
||||
MakeRecvInitialMetadata recv_initial_metadata(&op); |
||||
EXPECT_EQ(gbs->seq, 0); |
||||
PerformStreamOp(gbs, &op); |
||||
EXPECT_EQ(gbs->tx_code, kFirstCallId + 1); |
||||
EXPECT_EQ(gbs->seq, 0); |
||||
|
||||
// Just to trigger the callback.
|
||||
auto* gbt = reinterpret_cast<grpc_binder_transport*>(transport_); |
||||
gbt->transport_stream_receiver->NotifyRecvInitialMetadata(gbs->tx_code, |
||||
kDefaultMetadata); |
||||
PerformStreamOp(gbs, &op); |
||||
exec_ctx.Flush(); |
||||
} |
||||
} |
||||
|
||||
TEST_F(BinderTransportTest, PerformSendInitialMetadata) { |
||||
grpc_core::ExecCtx exec_ctx; |
||||
grpc_binder_stream* gbs = InitNewBinderStream(); |
||||
grpc_transport_stream_op_batch op{}; |
||||
grpc_transport_stream_op_batch_payload payload(nullptr); |
||||
op.payload = &payload; |
||||
const Metadata kInitialMetadata = kDefaultMetadata; |
||||
MakeSendInitialMetadata send_initial_metadata(kInitialMetadata, "", &op); |
||||
MockGrpcClosure mock_on_complete; |
||||
op.on_complete = mock_on_complete.GetGrpcClosure(); |
||||
|
||||
::testing::InSequence sequence; |
||||
EXPECT_CALL(GetWireWriter(), RpcCall(TransactionMatches( |
||||
kFlagPrefix, "", kInitialMetadata, ""))); |
||||
EXPECT_CALL(mock_on_complete, Callback); |
||||
|
||||
PerformStreamOp(gbs, &op); |
||||
exec_ctx.Flush(); |
||||
} |
||||
|
||||
TEST_F(BinderTransportTest, PerformSendInitialMetadataMethodRef) { |
||||
grpc_core::ExecCtx exec_ctx; |
||||
grpc_binder_stream* gbs = InitNewBinderStream(); |
||||
grpc_transport_stream_op_batch op{}; |
||||
grpc_transport_stream_op_batch_payload payload(nullptr); |
||||
op.payload = &payload; |
||||
const Metadata kInitialMetadata = kDefaultMetadata; |
||||
const std::string kMethodRef = kDefaultMethodRef; |
||||
MakeSendInitialMetadata send_initial_metadata(kInitialMetadata, kMethodRef, |
||||
&op); |
||||
MockGrpcClosure mock_on_complete; |
||||
op.on_complete = mock_on_complete.GetGrpcClosure(); |
||||
|
||||
::testing::InSequence sequence; |
||||
EXPECT_CALL(GetWireWriter(), |
||||
RpcCall(TransactionMatches(kFlagPrefix, kMethodRef.substr(1), |
||||
kInitialMetadata, ""))); |
||||
EXPECT_CALL(mock_on_complete, Callback); |
||||
|
||||
PerformStreamOp(gbs, &op); |
||||
exec_ctx.Flush(); |
||||
} |
||||
|
||||
TEST_F(BinderTransportTest, PerformSendMessage) { |
||||
grpc_core::ExecCtx exec_ctx; |
||||
grpc_binder_stream* gbs = InitNewBinderStream(); |
||||
grpc_transport_stream_op_batch op{}; |
||||
grpc_transport_stream_op_batch_payload payload(nullptr); |
||||
op.payload = &payload; |
||||
|
||||
const std::string kMessage = kDefaultMessage; |
||||
MakeSendMessage send_message(kMessage, &op); |
||||
MockGrpcClosure mock_on_complete; |
||||
op.on_complete = mock_on_complete.GetGrpcClosure(); |
||||
|
||||
::testing::InSequence sequence; |
||||
EXPECT_CALL( |
||||
GetWireWriter(), |
||||
RpcCall(TransactionMatches(kFlagMessageData, "", Metadata{}, kMessage))); |
||||
EXPECT_CALL(mock_on_complete, Callback); |
||||
|
||||
PerformStreamOp(gbs, &op); |
||||
exec_ctx.Flush(); |
||||
} |
||||
|
||||
TEST_F(BinderTransportTest, PerformSendTrailingMetadata) { |
||||
grpc_core::ExecCtx exec_ctx; |
||||
grpc_binder_stream* gbs = InitNewBinderStream(); |
||||
grpc_transport_stream_op_batch op{}; |
||||
grpc_transport_stream_op_batch_payload payload(nullptr); |
||||
op.payload = &payload; |
||||
// The wireformat guarantees that suffix metadata will always be empty.
|
||||
// TODO(waynetu): Check whether gRPC can internally add extra trailing
|
||||
// metadata.
|
||||
const Metadata kTrailingMetadata = {}; |
||||
MakeSendTrailingMetadata send_trailing_metadata(kTrailingMetadata, &op); |
||||
MockGrpcClosure mock_on_complete; |
||||
op.on_complete = mock_on_complete.GetGrpcClosure(); |
||||
|
||||
::testing::InSequence sequence; |
||||
EXPECT_CALL(GetWireWriter(), RpcCall(TransactionMatches( |
||||
kFlagSuffix, "", kTrailingMetadata, ""))); |
||||
EXPECT_CALL(mock_on_complete, Callback); |
||||
|
||||
PerformStreamOp(gbs, &op); |
||||
exec_ctx.Flush(); |
||||
} |
||||
|
||||
TEST_F(BinderTransportTest, PerformSendAll) { |
||||
grpc_core::ExecCtx exec_ctx; |
||||
grpc_binder_stream* gbs = InitNewBinderStream(); |
||||
grpc_transport_stream_op_batch op{}; |
||||
grpc_transport_stream_op_batch_payload payload(nullptr); |
||||
op.payload = &payload; |
||||
|
||||
const Metadata kInitialMetadata = kDefaultMetadata; |
||||
const std::string kMethodRef = kDefaultMethodRef; |
||||
MakeSendInitialMetadata send_initial_metadata(kInitialMetadata, kMethodRef, |
||||
&op); |
||||
|
||||
const std::string kMessage = kDefaultMessage; |
||||
MakeSendMessage send_message(kMessage, &op); |
||||
|
||||
// The wireformat guarantees that suffix metadata will always be empty.
|
||||
// TODO(waynetu): Check whether gRPC can internally add extra trailing
|
||||
// metadata.
|
||||
const Metadata kTrailingMetadata = {}; |
||||
MakeSendTrailingMetadata send_trailing_metadata(kTrailingMetadata, &op); |
||||
|
||||
MockGrpcClosure mock_on_complete; |
||||
op.on_complete = mock_on_complete.GetGrpcClosure(); |
||||
|
||||
::testing::InSequence sequence; |
||||
EXPECT_CALL(GetWireWriter(), |
||||
RpcCall(TransactionMatches( |
||||
kFlagPrefix | kFlagMessageData | kFlagSuffix, |
||||
kMethodRef.substr(1), kInitialMetadata, kMessage))); |
||||
EXPECT_CALL(mock_on_complete, Callback); |
||||
|
||||
PerformStreamOp(gbs, &op); |
||||
exec_ctx.Flush(); |
||||
} |
||||
|
||||
TEST_F(BinderTransportTest, PerformRecvInitialMetadata) { |
||||
grpc_core::ExecCtx exec_ctx; |
||||
grpc_binder_stream* gbs = InitNewBinderStream(); |
||||
grpc_transport_stream_op_batch op{}; |
||||
grpc_transport_stream_op_batch_payload payload(nullptr); |
||||
op.payload = &payload; |
||||
|
||||
MakeRecvInitialMetadata recv_initial_metadata(&op); |
||||
|
||||
const Metadata kInitialMetadata = kDefaultMetadata; |
||||
auto* gbt = reinterpret_cast<grpc_binder_transport*>(transport_); |
||||
gbt->transport_stream_receiver->NotifyRecvInitialMetadata(gbs->tx_code, |
||||
kInitialMetadata); |
||||
PerformStreamOp(gbs, &op); |
||||
exec_ctx.Flush(); |
||||
|
||||
VerifyMetadataEqual(kInitialMetadata, |
||||
recv_initial_metadata.grpc_initial_metadata); |
||||
} |
||||
|
||||
TEST_F(BinderTransportTest, PerformRecvInitialMetadataWithMethodRef) { |
||||
grpc_core::ExecCtx exec_ctx; |
||||
grpc_binder_stream* gbs = InitNewBinderStream(); |
||||
grpc_transport_stream_op_batch op{}; |
||||
grpc_transport_stream_op_batch_payload payload(nullptr); |
||||
op.payload = &payload; |
||||
|
||||
MakeRecvInitialMetadata recv_initial_metadata(&op); |
||||
|
||||
auto* gbt = reinterpret_cast<grpc_binder_transport*>(transport_); |
||||
const Metadata kInitialMetadataWithMethodRef = |
||||
AppendMethodRef(kDefaultMetadata, kDefaultMethodRef); |
||||
gbt->transport_stream_receiver->NotifyRecvInitialMetadata( |
||||
gbs->tx_code, kInitialMetadataWithMethodRef); |
||||
PerformStreamOp(gbs, &op); |
||||
exec_ctx.Flush(); |
||||
|
||||
VerifyMetadataEqual(kInitialMetadataWithMethodRef, |
||||
recv_initial_metadata.grpc_initial_metadata); |
||||
} |
||||
|
||||
TEST_F(BinderTransportTest, PerformRecvMessage) { |
||||
grpc_core::ExecCtx exec_ctx; |
||||
grpc_binder_stream* gbs = InitNewBinderStream(); |
||||
grpc_transport_stream_op_batch op{}; |
||||
grpc_transport_stream_op_batch_payload payload(nullptr); |
||||
op.payload = &payload; |
||||
|
||||
MakeRecvMessage recv_message(&op); |
||||
|
||||
auto* gbt = reinterpret_cast<grpc_binder_transport*>(transport_); |
||||
const std::string kMessage = kDefaultMessage; |
||||
gbt->transport_stream_receiver->NotifyRecvMessage(gbs->tx_code, kMessage); |
||||
|
||||
PerformStreamOp(gbs, &op); |
||||
exec_ctx.Flush(); |
||||
EXPECT_TRUE(recv_message.grpc_message->Next(SIZE_MAX, nullptr)); |
||||
grpc_slice slice; |
||||
recv_message.grpc_message->Pull(&slice); |
||||
EXPECT_EQ(kMessage, |
||||
std::string(reinterpret_cast<char*>(GRPC_SLICE_START_PTR(slice)), |
||||
GRPC_SLICE_LENGTH(slice))); |
||||
grpc_slice_unref_internal(slice); |
||||
} |
||||
|
||||
TEST_F(BinderTransportTest, PerformRecvTrailingMetadata) { |
||||
grpc_core::ExecCtx exec_ctx; |
||||
grpc_binder_stream* gbs = InitNewBinderStream(); |
||||
grpc_transport_stream_op_batch op{}; |
||||
grpc_transport_stream_op_batch_payload payload(nullptr); |
||||
op.payload = &payload; |
||||
|
||||
MakeRecvTrailingMetadata recv_trailing_metadata(&op); |
||||
|
||||
const Metadata kTrailingMetadata = kDefaultMetadata; |
||||
auto* gbt = reinterpret_cast<grpc_binder_transport*>(transport_); |
||||
constexpr int kStatus = kDefaultStatus; |
||||
gbt->transport_stream_receiver->NotifyRecvTrailingMetadata( |
||||
gbs->tx_code, kTrailingMetadata, kStatus); |
||||
PerformStreamOp(gbs, &op); |
||||
exec_ctx.Flush(); |
||||
VerifyMetadataEqual(AppendStatus(kTrailingMetadata, kStatus), |
||||
recv_trailing_metadata.grpc_trailing_metadata); |
||||
} |
||||
|
||||
TEST_F(BinderTransportTest, PerformRecvAll) { |
||||
grpc_core::ExecCtx exec_ctx; |
||||
grpc_binder_stream* gbs = InitNewBinderStream(); |
||||
grpc_transport_stream_op_batch op{}; |
||||
grpc_transport_stream_op_batch_payload payload(nullptr); |
||||
op.payload = &payload; |
||||
|
||||
MakeRecvInitialMetadata recv_initial_metadata(&op); |
||||
MakeRecvMessage recv_message(&op); |
||||
MakeRecvTrailingMetadata recv_trailing_metadata(&op); |
||||
|
||||
auto* gbt = reinterpret_cast<grpc_binder_transport*>(transport_); |
||||
const Metadata kInitialMetadataWithMethodRef = |
||||
AppendMethodRef(kDefaultMetadata, kDefaultMethodRef); |
||||
gbt->transport_stream_receiver->NotifyRecvInitialMetadata( |
||||
gbs->tx_code, kInitialMetadataWithMethodRef); |
||||
|
||||
const std::string kMessage = kDefaultMessage; |
||||
gbt->transport_stream_receiver->NotifyRecvMessage(gbs->tx_code, kMessage); |
||||
|
||||
Metadata trailing_metadata = kDefaultMetadata; |
||||
constexpr int kStatus = kDefaultStatus; |
||||
gbt->transport_stream_receiver->NotifyRecvTrailingMetadata( |
||||
gbs->tx_code, trailing_metadata, kStatus); |
||||
PerformStreamOp(gbs, &op); |
||||
exec_ctx.Flush(); |
||||
|
||||
VerifyMetadataEqual(kInitialMetadataWithMethodRef, |
||||
recv_initial_metadata.grpc_initial_metadata); |
||||
trailing_metadata.emplace_back("grpc-status", std::to_string(kStatus)); |
||||
VerifyMetadataEqual(trailing_metadata, |
||||
recv_trailing_metadata.grpc_trailing_metadata); |
||||
EXPECT_TRUE(recv_message.grpc_message->Next(SIZE_MAX, nullptr)); |
||||
grpc_slice slice; |
||||
recv_message.grpc_message->Pull(&slice); |
||||
EXPECT_EQ(kMessage, |
||||
std::string(reinterpret_cast<char*>(GRPC_SLICE_START_PTR(slice)), |
||||
GRPC_SLICE_LENGTH(slice))); |
||||
grpc_slice_unref_internal(slice); |
||||
} |
||||
|
||||
TEST_F(BinderTransportTest, PerformAllOps) { |
||||
grpc_core::ExecCtx exec_ctx; |
||||
grpc_binder_stream* gbs = InitNewBinderStream(); |
||||
grpc_transport_stream_op_batch op{}; |
||||
grpc_transport_stream_op_batch_payload payload(nullptr); |
||||
op.payload = &payload; |
||||
|
||||
const Metadata kSendInitialMetadata = kDefaultMetadata; |
||||
const std::string kMethodRef = kDefaultMethodRef; |
||||
MakeSendInitialMetadata send_initial_metadata(kSendInitialMetadata, |
||||
kMethodRef, &op); |
||||
|
||||
const std::string kSendMessage = kDefaultMessage; |
||||
MakeSendMessage send_message(kSendMessage, &op); |
||||
|
||||
// The wireformat guarantees that suffix metadata will always be empty.
|
||||
// TODO(waynetu): Check whether gRPC can internally add extra trailing
|
||||
// metadata.
|
||||
const Metadata kSendTrailingMetadata = {}; |
||||
MakeSendTrailingMetadata send_trailing_metadata(kSendTrailingMetadata, &op); |
||||
|
||||
MockGrpcClosure mock_on_complete; |
||||
op.on_complete = mock_on_complete.GetGrpcClosure(); |
||||
|
||||
// TODO(waynetu): Currently, we simply drop the prefix '/' from the :path
|
||||
// argument to obtain the method name. Update the test if this turns out to be
|
||||
// incorrect.
|
||||
EXPECT_CALL(GetWireWriter(), |
||||
RpcCall(TransactionMatches( |
||||
kFlagPrefix | kFlagMessageData | kFlagSuffix, |
||||
kMethodRef.substr(1), kSendInitialMetadata, kSendMessage))); |
||||
Expectation on_complete = EXPECT_CALL(mock_on_complete, Callback); |
||||
|
||||
// Recv callbacks can happen after the on_complete callback.
|
||||
MakeRecvInitialMetadata recv_initial_metadata( |
||||
&op, /* call_before = */ &on_complete); |
||||
MakeRecvMessage recv_message(&op, /* call_before = */ &on_complete); |
||||
MakeRecvTrailingMetadata recv_trailing_metadata( |
||||
&op, /* call_before = */ &on_complete); |
||||
|
||||
PerformStreamOp(gbs, &op); |
||||
|
||||
// Flush the execution context to force on_complete to run before recv
|
||||
// callbacks get scheduled.
|
||||
exec_ctx.Flush(); |
||||
|
||||
auto* gbt = reinterpret_cast<grpc_binder_transport*>(transport_); |
||||
const Metadata kRecvInitialMetadata = |
||||
AppendMethodRef(kDefaultMetadata, kDefaultMethodRef); |
||||
gbt->transport_stream_receiver->NotifyRecvInitialMetadata( |
||||
gbs->tx_code, kRecvInitialMetadata); |
||||
const std::string kRecvMessage = kDefaultMessage; |
||||
gbt->transport_stream_receiver->NotifyRecvMessage(gbs->tx_code, kRecvMessage); |
||||
const Metadata kRecvTrailingMetadata = kDefaultMetadata; |
||||
constexpr int kStatus = 0x1234; |
||||
gbt->transport_stream_receiver->NotifyRecvTrailingMetadata( |
||||
gbs->tx_code, kRecvTrailingMetadata, kStatus); |
||||
|
||||
exec_ctx.Flush(); |
||||
VerifyMetadataEqual(kRecvInitialMetadata, |
||||
recv_initial_metadata.grpc_initial_metadata); |
||||
VerifyMetadataEqual(AppendStatus(kRecvTrailingMetadata, kStatus), |
||||
recv_trailing_metadata.grpc_trailing_metadata); |
||||
|
||||
EXPECT_TRUE(recv_message.grpc_message->Next(SIZE_MAX, nullptr)); |
||||
grpc_slice slice; |
||||
recv_message.grpc_message->Pull(&slice); |
||||
EXPECT_EQ(kRecvMessage, |
||||
std::string(reinterpret_cast<char*>(GRPC_SLICE_START_PTR(slice)), |
||||
GRPC_SLICE_LENGTH(slice))); |
||||
grpc_slice_unref_internal(slice); |
||||
} |
||||
|
||||
TEST_F(BinderTransportTest, WireWriterRpcCallErrorPropagates) { |
||||
grpc_core::ExecCtx exec_ctx; |
||||
grpc_binder_stream* gbs = InitNewBinderStream(); |
||||
|
||||
MockGrpcClosure mock_on_complete1; |
||||
MockGrpcClosure mock_on_complete2; |
||||
|
||||
EXPECT_CALL(GetWireWriter(), RpcCall) |
||||
.WillOnce(Return(absl::OkStatus())) |
||||
.WillOnce(Return(absl::InternalError("WireWriter::RpcCall failed"))); |
||||
EXPECT_CALL(mock_on_complete1, Callback(GRPC_ERROR_NONE)); |
||||
EXPECT_CALL(mock_on_complete2, |
||||
Callback(GrpcErrorMessageContains("WireWriter::RpcCall failed"))); |
||||
|
||||
const Metadata kInitialMetadata = {}; |
||||
grpc_transport_stream_op_batch op1{}; |
||||
grpc_transport_stream_op_batch_payload payload1(nullptr); |
||||
op1.payload = &payload1; |
||||
MakeSendInitialMetadata send_initial_metadata1(kInitialMetadata, "", &op1); |
||||
op1.on_complete = mock_on_complete1.GetGrpcClosure(); |
||||
|
||||
grpc_transport_stream_op_batch op2{}; |
||||
grpc_transport_stream_op_batch_payload payload2(nullptr); |
||||
op2.payload = &payload2; |
||||
MakeSendInitialMetadata send_initial_metadata2(kInitialMetadata, "", &op2); |
||||
op2.on_complete = mock_on_complete2.GetGrpcClosure(); |
||||
|
||||
PerformStreamOp(gbs, &op1); |
||||
PerformStreamOp(gbs, &op2); |
||||
exec_ctx.Flush(); |
||||
} |
||||
|
||||
} // namespace grpc_binder
|
||||
|
||||
int main(int argc, char** argv) { |
||||
::testing::InitGoogleTest(&argc, argv); |
||||
grpc::testing::TestEnvironment env(argc, argv); |
||||
return RUN_ALL_TESTS(); |
||||
} |
||||
@ -0,0 +1,112 @@ |
||||
# Copyright 2021 gRPC authors. |
||||
# |
||||
# Licensed under the Apache License, Version 2.0 (the "License"); |
||||
# you may not use this file except in compliance with the License. |
||||
# You may obtain a copy of the License at |
||||
# |
||||
# http://www.apache.org/licenses/LICENSE-2.0 |
||||
# |
||||
# Unless required by applicable law or agreed to in writing, software |
||||
# distributed under the License is distributed on an "AS IS" BASIS, |
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
# See the License for the specific language governing permissions and |
||||
# limitations under the License. |
||||
|
||||
load("//bazel:grpc_build_system.bzl", "grpc_cc_library", "grpc_cc_test", "grpc_package", "grpc_proto_library") |
||||
|
||||
licenses(["notice"]) |
||||
|
||||
grpc_package( |
||||
name = "test/core/transport/binder/end2end", |
||||
visibility = "tests", |
||||
) |
||||
|
||||
grpc_cc_library( |
||||
name = "fake_binder", |
||||
testonly = 1, |
||||
srcs = ["fake_binder.cc"], |
||||
hdrs = ["fake_binder.h"], |
||||
external_deps = [ |
||||
"absl/memory", |
||||
"absl/random", |
||||
"absl/strings", |
||||
"absl/strings:str_format", |
||||
"absl/time", |
||||
"absl/types:variant", |
||||
], |
||||
deps = [ |
||||
"//:gpr_base", |
||||
"//src/core/ext/transport/binder/wire_format:binder", |
||||
"//src/core/ext/transport/binder/wire_format:wire_reader", |
||||
], |
||||
) |
||||
|
||||
grpc_cc_test( |
||||
name = "fake_binder_test", |
||||
srcs = ["fake_binder_test.cc"], |
||||
external_deps = [ |
||||
"absl/strings", |
||||
"absl/time", |
||||
"gtest", |
||||
], |
||||
language = "C++", |
||||
uses_polling = False, |
||||
deps = [ |
||||
":fake_binder", |
||||
"//test/core/util:grpc_test_util", |
||||
], |
||||
) |
||||
|
||||
grpc_cc_library( |
||||
name = "end2end_binder_channel", |
||||
testonly = 1, |
||||
srcs = ["testing_channel_create.cc"], |
||||
hdrs = ["testing_channel_create.h"], |
||||
external_deps = [], |
||||
deps = [ |
||||
":fake_binder", |
||||
"//:grpc++_base", |
||||
"//:grpc_base_c", |
||||
"//src/core/ext/transport/binder/transport:binder_transport", |
||||
"//src/core/ext/transport/binder/wire_format:wire_reader", |
||||
], |
||||
) |
||||
|
||||
grpc_proto_library( |
||||
name = "echo_grpc_proto", |
||||
srcs = ["echo.proto"], |
||||
) |
||||
|
||||
grpc_cc_library( |
||||
name = "echo_service", |
||||
testonly = 1, |
||||
srcs = ["echo_service.cc"], |
||||
hdrs = ["echo_service.h"], |
||||
external_deps = [ |
||||
"absl/strings", |
||||
"absl/strings:str_format", |
||||
"absl/time", |
||||
], |
||||
deps = [ |
||||
":echo_grpc_proto", |
||||
], |
||||
) |
||||
|
||||
grpc_cc_test( |
||||
name = "end2end_binder_transport_test", |
||||
srcs = ["end2end_binder_transport_test.cc"], |
||||
external_deps = [ |
||||
"absl/memory", |
||||
"absl/time", |
||||
"gtest", |
||||
], |
||||
language = "C++", |
||||
deps = [ |
||||
":echo_service", |
||||
":end2end_binder_channel", |
||||
":fake_binder", |
||||
"//src/core/ext/transport/binder/transport:binder_transport", |
||||
"//src/core/ext/transport/binder/wire_format:wire_reader", |
||||
"//test/core/util:grpc_test_util", |
||||
], |
||||
) |
||||
@ -0,0 +1,38 @@ |
||||
// Copyright 2021 gRPC authors. |
||||
// |
||||
// Licensed under the Apache License, Version 2.0 (the "License"); |
||||
// you may not use this file except in compliance with the License. |
||||
// You may obtain a copy of the License at |
||||
// |
||||
// http://www.apache.org/licenses/LICENSE-2.0 |
||||
// |
||||
// Unless required by applicable law or agreed to in writing, software |
||||
// distributed under the License is distributed on an "AS IS" BASIS, |
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
// See the License for the specific language governing permissions and |
||||
// limitations under the License. |
||||
|
||||
// A simple RPC service that echos what the client passes in. The request and |
||||
// the response simply contains the text represented in a string. |
||||
// |
||||
// This service is for end-to-end testing with fake binder tunnels. |
||||
syntax = "proto3"; |
||||
|
||||
// TODO(waynetu): This can be replaced by EchoTestService in |
||||
// src/proto/grpc/testing/echo.proto |
||||
package grpc_binder.end2end_testing; |
||||
|
||||
message EchoRequest { |
||||
string text = 1; |
||||
} |
||||
|
||||
message EchoResponse { |
||||
string text = 1; |
||||
} |
||||
|
||||
service EchoService { |
||||
rpc EchoUnaryCall(EchoRequest) returns (EchoResponse); |
||||
rpc EchoServerStreamingCall(EchoRequest) returns (stream EchoResponse); |
||||
rpc EchoClientStreamingCall(stream EchoRequest) returns (EchoResponse); |
||||
rpc EchoBiDirStreamingCall(stream EchoRequest) returns (stream EchoResponse); |
||||
} |
||||
@ -0,0 +1,83 @@ |
||||
// Copyright 2021 gRPC authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "test/core/transport/binder/end2end/echo_service.h" |
||||
|
||||
#include <string> |
||||
|
||||
#include "absl/strings/str_format.h" |
||||
#include "absl/time/time.h" |
||||
|
||||
namespace grpc_binder { |
||||
namespace end2end_testing { |
||||
|
||||
const absl::string_view EchoServer::kCancelledText = "cancel"; |
||||
const absl::string_view EchoServer::kTimeoutText = "timeout"; |
||||
const size_t EchoServer::kServerStreamingCounts = 100; |
||||
|
||||
grpc::Status EchoServer::EchoUnaryCall(grpc::ServerContext* /*context*/, |
||||
const EchoRequest* request, |
||||
EchoResponse* response) { |
||||
const std::string& data = request->text(); |
||||
if (data == kCancelledText) { |
||||
return grpc::Status::CANCELLED; |
||||
} |
||||
if (data == kTimeoutText) { |
||||
absl::SleepFor(absl::Seconds(5)); |
||||
} |
||||
response->set_text(data); |
||||
return grpc::Status::OK; |
||||
} |
||||
|
||||
grpc::Status EchoServer::EchoServerStreamingCall( |
||||
grpc::ServerContext* /*context*/, const EchoRequest* request, |
||||
grpc::ServerWriter<EchoResponse>* writer) { |
||||
const std::string& data = request->text(); |
||||
if (data == kTimeoutText) { |
||||
absl::SleepFor(absl::Seconds(5)); |
||||
} |
||||
for (size_t i = 0; i < kServerStreamingCounts; ++i) { |
||||
EchoResponse response; |
||||
response.set_text(absl::StrFormat("%s(%d)", data, i)); |
||||
writer->Write(response); |
||||
} |
||||
return grpc::Status::OK; |
||||
} |
||||
|
||||
grpc::Status EchoServer::EchoClientStreamingCall( |
||||
grpc::ServerContext* /*context*/, grpc::ServerReader<EchoRequest>* reader, |
||||
EchoResponse* response) { |
||||
EchoRequest request; |
||||
std::string result = ""; |
||||
while (reader->Read(&request)) { |
||||
result += request.text(); |
||||
} |
||||
response->set_text(result); |
||||
return grpc::Status::OK; |
||||
} |
||||
|
||||
grpc::Status EchoServer::EchoBiDirStreamingCall( |
||||
grpc::ServerContext* /*context*/, |
||||
grpc::ServerReaderWriter<EchoResponse, EchoRequest>* stream) { |
||||
EchoRequest request; |
||||
while (stream->Read(&request)) { |
||||
EchoResponse response; |
||||
response.set_text(request.text()); |
||||
stream->Write(response); |
||||
} |
||||
return grpc::Status::OK; |
||||
} |
||||
|
||||
} // namespace end2end_testing
|
||||
} // namespace grpc_binder
|
||||
@ -0,0 +1,51 @@ |
||||
// Copyright 2021 gRPC authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#ifndef TEST_CORE_TRANSPORT_BINDER_END2END_ECHO_SERVICE_H |
||||
#define TEST_CORE_TRANSPORT_BINDER_END2END_ECHO_SERVICE_H |
||||
|
||||
#include "absl/strings/string_view.h" |
||||
#include "test/core/transport/binder/end2end/echo.grpc.pb.h" |
||||
|
||||
namespace grpc_binder { |
||||
namespace end2end_testing { |
||||
|
||||
// TODO(waynetu): Replace this with TestServiceImpl declared in
|
||||
// test/cpp/end2end/test_service_impl.h
|
||||
class EchoServer final : public EchoService::Service { |
||||
public: |
||||
static const absl::string_view kCancelledText; |
||||
static const absl::string_view kTimeoutText; |
||||
|
||||
grpc::Status EchoUnaryCall(grpc::ServerContext* context, |
||||
const EchoRequest* request, |
||||
EchoResponse* response) override; |
||||
|
||||
static const size_t kServerStreamingCounts; |
||||
|
||||
grpc::Status EchoServerStreamingCall( |
||||
grpc::ServerContext* context, const EchoRequest* request, |
||||
grpc::ServerWriter<EchoResponse>* writer) override; |
||||
grpc::Status EchoClientStreamingCall(grpc::ServerContext* context, |
||||
grpc::ServerReader<EchoRequest>* reader, |
||||
EchoResponse* response) override; |
||||
grpc::Status EchoBiDirStreamingCall( |
||||
grpc::ServerContext* context, |
||||
grpc::ServerReaderWriter<EchoResponse, EchoRequest>* stream) override; |
||||
}; |
||||
|
||||
} // namespace end2end_testing
|
||||
} // namespace grpc_binder
|
||||
|
||||
#endif // TEST_CORE_TRANSPORT_BINDER_END2END_ECHO_SERVICE_H_
|
||||
@ -0,0 +1,306 @@ |
||||
// Copyright 2021 gRPC authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include <gmock/gmock.h> |
||||
#include <gtest/gtest.h> |
||||
|
||||
#include <grpcpp/grpcpp.h> |
||||
#include <string> |
||||
#include <thread> |
||||
#include <utility> |
||||
|
||||
#include "absl/memory/memory.h" |
||||
#include "absl/time/time.h" |
||||
#include "src/core/ext/transport/binder/transport/binder_transport.h" |
||||
#include "src/core/ext/transport/binder/wire_format/wire_reader_impl.h" |
||||
#include "test/core/transport/binder/end2end/echo_service.h" |
||||
#include "test/core/transport/binder/end2end/fake_binder.h" |
||||
#include "test/core/transport/binder/end2end/testing_channel_create.h" |
||||
#include "test/core/util/test_config.h" |
||||
|
||||
namespace grpc_binder { |
||||
|
||||
namespace { |
||||
|
||||
class End2EndBinderTransportTest |
||||
: public ::testing::TestWithParam<absl::Duration> { |
||||
public: |
||||
End2EndBinderTransportTest() { |
||||
end2end_testing::g_transaction_processor = |
||||
new end2end_testing::TransactionProcessor(GetParam()); |
||||
} |
||||
|
||||
~End2EndBinderTransportTest() override { |
||||
delete end2end_testing::g_transaction_processor; |
||||
} |
||||
|
||||
static void SetUpTestSuite() { grpc_init(); } |
||||
static void TearDownTestSuite() { grpc_shutdown(); } |
||||
|
||||
std::shared_ptr<grpc::Channel> BinderChannel( |
||||
grpc::Server* server, const grpc::ChannelArguments& args) { |
||||
return end2end_testing::BinderChannelForTesting(server, args); |
||||
} |
||||
}; |
||||
|
||||
using end2end_testing::EchoRequest; |
||||
using end2end_testing::EchoResponse; |
||||
using end2end_testing::EchoService; |
||||
|
||||
} // namespace
|
||||
|
||||
TEST_P(End2EndBinderTransportTest, SetupTransport) { |
||||
grpc_transport *client_transport, *server_transport; |
||||
std::tie(client_transport, server_transport) = |
||||
end2end_testing::CreateClientServerBindersPairForTesting(); |
||||
EXPECT_NE(client_transport, nullptr); |
||||
EXPECT_NE(server_transport, nullptr); |
||||
|
||||
grpc_transport_destroy(client_transport); |
||||
grpc_transport_destroy(server_transport); |
||||
} |
||||
|
||||
TEST_P(End2EndBinderTransportTest, UnaryCallThroughFakeBinderChannel) { |
||||
grpc::ChannelArguments args; |
||||
grpc::ServerBuilder builder; |
||||
end2end_testing::EchoServer service; |
||||
builder.RegisterService(&service); |
||||
std::unique_ptr<grpc::Server> server = builder.BuildAndStart(); |
||||
std::shared_ptr<grpc::Channel> channel = BinderChannel(server.get(), args); |
||||
std::unique_ptr<EchoService::Stub> stub = EchoService::NewStub(channel); |
||||
grpc::ClientContext context; |
||||
EchoRequest request; |
||||
EchoResponse response; |
||||
request.set_text("it works!"); |
||||
grpc::Status status = stub->EchoUnaryCall(&context, request, &response); |
||||
EXPECT_TRUE(status.ok()); |
||||
EXPECT_EQ(response.text(), "it works!"); |
||||
|
||||
server->Shutdown(); |
||||
} |
||||
|
||||
TEST_P(End2EndBinderTransportTest, |
||||
UnaryCallThroughFakeBinderChannelNonOkStatus) { |
||||
grpc::ChannelArguments args; |
||||
grpc::ServerBuilder builder; |
||||
end2end_testing::EchoServer service; |
||||
builder.RegisterService(&service); |
||||
std::unique_ptr<grpc::Server> server = builder.BuildAndStart(); |
||||
std::shared_ptr<grpc::Channel> channel = BinderChannel(server.get(), args); |
||||
std::unique_ptr<EchoService::Stub> stub = EchoService::NewStub(channel); |
||||
grpc::ClientContext context; |
||||
EchoRequest request; |
||||
EchoResponse response; |
||||
request.set_text(std::string(end2end_testing::EchoServer::kCancelledText)); |
||||
// Server will not response the client with message data, however, since all
|
||||
// callbacks after the trailing metadata are cancelled, we shall not be
|
||||
// blocked here.
|
||||
grpc::Status status = stub->EchoUnaryCall(&context, request, &response); |
||||
EXPECT_FALSE(status.ok()); |
||||
|
||||
server->Shutdown(); |
||||
} |
||||
|
||||
TEST_P(End2EndBinderTransportTest, |
||||
UnaryCallThroughFakeBinderChannelServerTimeout) { |
||||
grpc::ChannelArguments args; |
||||
grpc::ServerBuilder builder; |
||||
end2end_testing::EchoServer service; |
||||
builder.RegisterService(&service); |
||||
std::unique_ptr<grpc::Server> server = builder.BuildAndStart(); |
||||
std::shared_ptr<grpc::Channel> channel = BinderChannel(server.get(), args); |
||||
std::unique_ptr<EchoService::Stub> stub = EchoService::NewStub(channel); |
||||
grpc::ClientContext context; |
||||
context.set_deadline(absl::ToChronoTime(absl::Now() + absl::Seconds(1))); |
||||
EchoRequest request; |
||||
EchoResponse response; |
||||
request.set_text(std::string(end2end_testing::EchoServer::kTimeoutText)); |
||||
grpc::Status status = stub->EchoUnaryCall(&context, request, &response); |
||||
EXPECT_FALSE(status.ok()); |
||||
EXPECT_EQ(status.error_message(), "Deadline Exceeded"); |
||||
|
||||
server->Shutdown(); |
||||
} |
||||
|
||||
// Temporarily disabled due to a potential deadlock in our design.
|
||||
// TODO(waynetu): Enable this test once the issue is resolved.
|
||||
TEST_P(End2EndBinderTransportTest, |
||||
UnaryCallThroughFakeBinderChannelClientTimeout) { |
||||
grpc::ChannelArguments args; |
||||
grpc::ServerBuilder builder; |
||||
end2end_testing::EchoServer service; |
||||
builder.RegisterService(&service); |
||||
std::unique_ptr<grpc::Server> server = builder.BuildAndStart(); |
||||
std::shared_ptr<grpc::Channel> channel = BinderChannel(server.get(), args); |
||||
std::unique_ptr<EchoService::Stub> stub = EchoService::NewStub(channel); |
||||
|
||||
// Set transaction delay to a large number. This happens after the channel
|
||||
// creation so that we don't need to wait that long for client and server to
|
||||
// be connected.
|
||||
end2end_testing::g_transaction_processor->SetDelay(absl::Seconds(5)); |
||||
|
||||
grpc::ClientContext context; |
||||
context.set_deadline(absl::ToChronoTime(absl::Now() + absl::Seconds(1))); |
||||
EchoRequest request; |
||||
EchoResponse response; |
||||
request.set_text("normal-text"); |
||||
grpc::Status status = stub->EchoUnaryCall(&context, request, &response); |
||||
EXPECT_FALSE(status.ok()); |
||||
EXPECT_EQ(status.error_message(), "Deadline Exceeded"); |
||||
|
||||
server->Shutdown(); |
||||
} |
||||
|
||||
TEST_P(End2EndBinderTransportTest, |
||||
ServerStreamingCallThroughFakeBinderChannel) { |
||||
grpc::ChannelArguments args; |
||||
grpc::ServerBuilder builder; |
||||
end2end_testing::EchoServer service; |
||||
builder.RegisterService(&service); |
||||
std::unique_ptr<grpc::Server> server = builder.BuildAndStart(); |
||||
std::shared_ptr<grpc::Channel> channel = BinderChannel(server.get(), args); |
||||
std::unique_ptr<EchoService::Stub> stub = EchoService::NewStub(channel); |
||||
grpc::ClientContext context; |
||||
EchoRequest request; |
||||
request.set_text("it works!"); |
||||
std::unique_ptr<grpc::ClientReader<EchoResponse>> reader = |
||||
stub->EchoServerStreamingCall(&context, request); |
||||
EchoResponse response; |
||||
size_t cnt = 0; |
||||
while (reader->Read(&response)) { |
||||
EXPECT_EQ(response.text(), absl::StrFormat("it works!(%d)", cnt)); |
||||
cnt++; |
||||
} |
||||
EXPECT_EQ(cnt, end2end_testing::EchoServer::kServerStreamingCounts); |
||||
grpc::Status status = reader->Finish(); |
||||
EXPECT_TRUE(status.ok()); |
||||
|
||||
server->Shutdown(); |
||||
} |
||||
|
||||
TEST_P(End2EndBinderTransportTest, |
||||
ServerStreamingCallThroughFakeBinderChannelServerTimeout) { |
||||
grpc::ChannelArguments args; |
||||
grpc::ServerBuilder builder; |
||||
end2end_testing::EchoServer service; |
||||
builder.RegisterService(&service); |
||||
std::unique_ptr<grpc::Server> server = builder.BuildAndStart(); |
||||
std::shared_ptr<grpc::Channel> channel = BinderChannel(server.get(), args); |
||||
std::unique_ptr<EchoService::Stub> stub = EchoService::NewStub(channel); |
||||
grpc::ClientContext context; |
||||
context.set_deadline(absl::ToChronoTime(absl::Now() + absl::Seconds(1))); |
||||
EchoRequest request; |
||||
request.set_text(std::string(end2end_testing::EchoServer::kTimeoutText)); |
||||
std::unique_ptr<grpc::ClientReader<EchoResponse>> reader = |
||||
stub->EchoServerStreamingCall(&context, request); |
||||
EchoResponse response; |
||||
EXPECT_FALSE(reader->Read(&response)); |
||||
grpc::Status status = reader->Finish(); |
||||
EXPECT_FALSE(status.ok()); |
||||
EXPECT_EQ(status.error_message(), "Deadline Exceeded"); |
||||
|
||||
server->Shutdown(); |
||||
} |
||||
|
||||
TEST_P(End2EndBinderTransportTest, |
||||
ClientStreamingCallThroughFakeBinderChannel) { |
||||
grpc::ChannelArguments args; |
||||
grpc::ServerBuilder builder; |
||||
end2end_testing::EchoServer service; |
||||
builder.RegisterService(&service); |
||||
std::unique_ptr<grpc::Server> server = builder.BuildAndStart(); |
||||
std::shared_ptr<grpc::Channel> channel = BinderChannel(server.get(), args); |
||||
std::unique_ptr<EchoService::Stub> stub = EchoService::NewStub(channel); |
||||
grpc::ClientContext context; |
||||
EchoResponse response; |
||||
std::unique_ptr<grpc::ClientWriter<EchoRequest>> writer = |
||||
stub->EchoClientStreamingCall(&context, &response); |
||||
constexpr size_t kClientStreamingCounts = 100; |
||||
std::string expected = ""; |
||||
for (size_t i = 0; i < kClientStreamingCounts; ++i) { |
||||
EchoRequest request; |
||||
request.set_text(absl::StrFormat("it works!(%d)", i)); |
||||
writer->Write(request); |
||||
expected += absl::StrFormat("it works!(%d)", i); |
||||
} |
||||
writer->WritesDone(); |
||||
grpc::Status status = writer->Finish(); |
||||
EXPECT_TRUE(status.ok()); |
||||
EXPECT_EQ(response.text(), expected); |
||||
|
||||
server->Shutdown(); |
||||
} |
||||
|
||||
TEST_P(End2EndBinderTransportTest, BiDirStreamingCallThroughFakeBinderChannel) { |
||||
grpc::ChannelArguments args; |
||||
grpc::ServerBuilder builder; |
||||
end2end_testing::EchoServer service; |
||||
builder.RegisterService(&service); |
||||
std::unique_ptr<grpc::Server> server = builder.BuildAndStart(); |
||||
std::shared_ptr<grpc::Channel> channel = BinderChannel(server.get(), args); |
||||
std::unique_ptr<EchoService::Stub> stub = EchoService::NewStub(channel); |
||||
grpc::ClientContext context; |
||||
EchoResponse response; |
||||
std::shared_ptr<grpc::ClientReaderWriter<EchoRequest, EchoResponse>> stream = |
||||
stub->EchoBiDirStreamingCall(&context); |
||||
constexpr size_t kBiDirStreamingCounts = 100; |
||||
|
||||
struct WriterArgs { |
||||
std::shared_ptr<grpc::ClientReaderWriter<EchoRequest, EchoResponse>> stream; |
||||
size_t bi_dir_streaming_counts; |
||||
} writer_args; |
||||
|
||||
writer_args.stream = stream; |
||||
writer_args.bi_dir_streaming_counts = kBiDirStreamingCounts; |
||||
|
||||
auto writer_fn = [](void* arg) { |
||||
const WriterArgs& args = *static_cast<WriterArgs*>(arg); |
||||
EchoResponse response; |
||||
for (size_t i = 0; i < args.bi_dir_streaming_counts; ++i) { |
||||
EchoRequest request; |
||||
request.set_text(absl::StrFormat("it works!(%d)", i)); |
||||
args.stream->Write(request); |
||||
} |
||||
args.stream->WritesDone(); |
||||
}; |
||||
|
||||
grpc_core::Thread writer_thread("writer-thread", writer_fn, |
||||
static_cast<void*>(&writer_args)); |
||||
writer_thread.Start(); |
||||
for (size_t i = 0; i < kBiDirStreamingCounts; ++i) { |
||||
EchoResponse response; |
||||
EXPECT_TRUE(stream->Read(&response)); |
||||
EXPECT_EQ(response.text(), absl::StrFormat("it works!(%d)", i)); |
||||
} |
||||
grpc::Status status = stream->Finish(); |
||||
EXPECT_TRUE(status.ok()); |
||||
writer_thread.Join(); |
||||
|
||||
server->Shutdown(); |
||||
} |
||||
|
||||
INSTANTIATE_TEST_SUITE_P( |
||||
End2EndBinderTransportTestWithDifferentDelayTimes, |
||||
End2EndBinderTransportTest, |
||||
testing::Values(absl::ZeroDuration(), absl::Nanoseconds(10), |
||||
absl::Microseconds(10), absl::Microseconds(100), |
||||
absl::Milliseconds(1), absl::Milliseconds(20))); |
||||
|
||||
} // namespace grpc_binder
|
||||
|
||||
int main(int argc, char** argv) { |
||||
::testing::InitGoogleTest(&argc, argv); |
||||
grpc::testing::TestEnvironment env(argc, argv); |
||||
return RUN_ALL_TESTS(); |
||||
} |
||||
@ -0,0 +1,269 @@ |
||||
// Copyright 2021 gRPC authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "test/core/transport/binder/end2end/fake_binder.h" |
||||
|
||||
#include <grpc/support/log.h> |
||||
|
||||
#include <string> |
||||
#include <utility> |
||||
|
||||
namespace grpc_binder { |
||||
namespace end2end_testing { |
||||
|
||||
TransactionProcessor* g_transaction_processor = nullptr; |
||||
|
||||
FakeWritableParcel::FakeWritableParcel() : data_(1) {} |
||||
|
||||
int32_t FakeWritableParcel::GetDataPosition() const { return data_position_; } |
||||
|
||||
absl::Status FakeWritableParcel::SetDataPosition(int32_t pos) { |
||||
if (data_.size() < static_cast<size_t>(pos) + 1) { |
||||
data_.resize(pos + 1); |
||||
} |
||||
data_position_ = pos; |
||||
return absl::OkStatus(); |
||||
} |
||||
|
||||
absl::Status FakeWritableParcel::WriteInt32(int32_t data) { |
||||
data_[data_position_] = data; |
||||
SetDataPosition(data_position_ + 1).IgnoreError(); |
||||
return absl::OkStatus(); |
||||
} |
||||
|
||||
absl::Status FakeWritableParcel::WriteBinder(HasRawBinder* binder) { |
||||
data_[data_position_] = binder->GetRawBinder(); |
||||
SetDataPosition(data_position_ + 1).IgnoreError(); |
||||
return absl::OkStatus(); |
||||
} |
||||
|
||||
absl::Status FakeWritableParcel::WriteString(absl::string_view s) { |
||||
data_[data_position_] = std::string(s); |
||||
SetDataPosition(data_position_ + 1).IgnoreError(); |
||||
return absl::OkStatus(); |
||||
} |
||||
|
||||
absl::Status FakeWritableParcel::WriteByteArray(const int8_t* buffer, |
||||
int32_t length) { |
||||
data_[data_position_] = std::vector<int8_t>(buffer, buffer + length); |
||||
SetDataPosition(data_position_ + 1).IgnoreError(); |
||||
return absl::OkStatus(); |
||||
} |
||||
|
||||
absl::Status FakeReadableParcel::ReadInt32(int32_t* data) const { |
||||
if (data_position_ >= data_.size() || |
||||
!absl::holds_alternative<int32_t>(data_[data_position_])) { |
||||
return absl::InternalError("ReadInt32 failed"); |
||||
} |
||||
*data = absl::get<int32_t>(data_[data_position_++]); |
||||
return absl::OkStatus(); |
||||
} |
||||
|
||||
absl::Status FakeReadableParcel::ReadBinder( |
||||
std::unique_ptr<Binder>* data) const { |
||||
if (data_position_ >= data_.size() || |
||||
!absl::holds_alternative<void*>(data_[data_position_])) { |
||||
return absl::InternalError("ReadBinder failed"); |
||||
} |
||||
void* endpoint = absl::get<void*>(data_[data_position_++]); |
||||
if (!endpoint) return absl::InternalError("ReadBinder failed"); |
||||
*data = absl::make_unique<FakeBinder>(static_cast<FakeEndpoint*>(endpoint)); |
||||
return absl::OkStatus(); |
||||
} |
||||
|
||||
absl::Status FakeReadableParcel::ReadString(char data[111]) const { |
||||
if (data_position_ >= data_.size() || |
||||
!absl::holds_alternative<std::string>(data_[data_position_])) { |
||||
return absl::InternalError("ReadString failed"); |
||||
} |
||||
const std::string& s = absl::get<std::string>(data_[data_position_++]); |
||||
if (s.size() >= 100) return absl::InternalError("ReadString failed"); |
||||
std::memcpy(data, s.data(), s.size()); |
||||
return absl::OkStatus(); |
||||
} |
||||
|
||||
absl::Status FakeReadableParcel::ReadByteArray(std::string* data) const { |
||||
if (data_position_ >= data_.size() || |
||||
!absl::holds_alternative<std::vector<int8_t>>(data_[data_position_])) { |
||||
return absl::InternalError("ReadByteArray failed"); |
||||
} |
||||
const std::vector<int8_t>& byte_array = |
||||
absl::get<std::vector<int8_t>>(data_[data_position_++]); |
||||
data->resize(byte_array.size()); |
||||
for (size_t i = 0; i < byte_array.size(); ++i) { |
||||
(*data)[i] = byte_array[i]; |
||||
} |
||||
return absl::OkStatus(); |
||||
} |
||||
|
||||
absl::Status FakeBinder::Transact(BinderTransportTxCode tx_code) { |
||||
endpoint_->tunnel->EnQueueTransaction(endpoint_->other_end, tx_code, |
||||
input_->MoveData()); |
||||
return absl::OkStatus(); |
||||
} |
||||
|
||||
FakeTransactionReceiver::FakeTransactionReceiver( |
||||
grpc_core::RefCountedPtr<WireReader> wire_reader_ref, |
||||
TransactionReceiver::OnTransactCb transact_cb) { |
||||
persistent_tx_receiver_ = &g_transaction_processor->NewPersistentTxReceiver( |
||||
std::move(wire_reader_ref), std::move(transact_cb), |
||||
absl::make_unique<FakeBinderTunnel>()); |
||||
} |
||||
|
||||
std::unique_ptr<TransactionReceiver> FakeBinder::ConstructTxReceiver( |
||||
grpc_core::RefCountedPtr<WireReader> wire_reader_ref, |
||||
TransactionReceiver::OnTransactCb cb) const { |
||||
return absl::make_unique<FakeTransactionReceiver>(wire_reader_ref, cb); |
||||
} |
||||
|
||||
void* FakeTransactionReceiver::GetRawBinder() { |
||||
return persistent_tx_receiver_->tunnel_->GetSendEndpoint(); |
||||
} |
||||
|
||||
std::unique_ptr<Binder> FakeTransactionReceiver::GetSender() const { |
||||
return absl::make_unique<FakeBinder>( |
||||
persistent_tx_receiver_->tunnel_->GetSendEndpoint()); |
||||
} |
||||
|
||||
PersistentFakeTransactionReceiver::PersistentFakeTransactionReceiver( |
||||
grpc_core::RefCountedPtr<WireReader> wire_reader_ref, |
||||
TransactionReceiver::OnTransactCb cb, |
||||
std::unique_ptr<FakeBinderTunnel> tunnel) |
||||
: wire_reader_ref_(std::move(wire_reader_ref)), |
||||
callback_(std::move(cb)), |
||||
tunnel_(std::move(tunnel)) { |
||||
FakeEndpoint* recv_endpoint = tunnel_->GetRecvEndpoint(); |
||||
recv_endpoint->owner = this; |
||||
} |
||||
|
||||
TransactionProcessor::TransactionProcessor(absl::Duration delay) |
||||
: delay_nsec_(absl::ToInt64Nanoseconds(delay)), |
||||
tx_thread_( |
||||
"process-thread", |
||||
[](void* arg) { |
||||
auto* self = static_cast<TransactionProcessor*>(arg); |
||||
self->ProcessLoop(); |
||||
}, |
||||
this), |
||||
terminated_(false) { |
||||
tx_thread_.Start(); |
||||
} |
||||
|
||||
void TransactionProcessor::SetDelay(absl::Duration delay) { |
||||
delay_nsec_ = absl::ToInt64Nanoseconds(delay); |
||||
} |
||||
|
||||
void TransactionProcessor::Terminate() { |
||||
if (!terminated_.load(std::memory_order_seq_cst)) { |
||||
gpr_log(GPR_INFO, "Terminating the processor"); |
||||
terminated_.store(true, std::memory_order_seq_cst); |
||||
tx_thread_.Join(); |
||||
gpr_log(GPR_INFO, "Processor terminated"); |
||||
} |
||||
} |
||||
|
||||
void TransactionProcessor::WaitForNextTransaction() { |
||||
absl::Time now = absl::Now(); |
||||
if (now < deliver_time_) { |
||||
absl::Duration diff = deliver_time_ - now; |
||||
// Release the lock before going to sleep.
|
||||
mu_.Unlock(); |
||||
absl::SleepFor(diff); |
||||
mu_.Lock(); |
||||
} |
||||
} |
||||
|
||||
void TransactionProcessor::Flush() { |
||||
while (true) { |
||||
FakeEndpoint* target = nullptr; |
||||
BinderTransportTxCode tx_code{}; |
||||
FakeData data; |
||||
mu_.Lock(); |
||||
if (tx_queue_.empty()) { |
||||
mu_.Unlock(); |
||||
break; |
||||
} |
||||
WaitForNextTransaction(); |
||||
std::tie(target, tx_code, data) = std::move(tx_queue_.front()); |
||||
tx_queue_.pop(); |
||||
if (!tx_queue_.empty()) { |
||||
deliver_time_ = absl::Now() + GetRandomDelay(); |
||||
} |
||||
mu_.Unlock(); |
||||
auto* tx_receiver = |
||||
static_cast<PersistentFakeTransactionReceiver*>(target->owner); |
||||
auto parcel = absl::make_unique<FakeReadableParcel>(std::move(data)); |
||||
tx_receiver->Receive(tx_code, parcel.get()).IgnoreError(); |
||||
} |
||||
} |
||||
|
||||
void TransactionProcessor::ProcessLoop() { |
||||
while (!terminated_.load(std::memory_order_seq_cst)) { |
||||
FakeEndpoint* target = nullptr; |
||||
BinderTransportTxCode tx_code{}; |
||||
FakeData data; |
||||
mu_.Lock(); |
||||
if (tx_queue_.empty()) { |
||||
mu_.Unlock(); |
||||
continue; |
||||
} |
||||
WaitForNextTransaction(); |
||||
std::tie(target, tx_code, data) = std::move(tx_queue_.front()); |
||||
tx_queue_.pop(); |
||||
if (!tx_queue_.empty()) { |
||||
deliver_time_ = absl::Now() + GetRandomDelay(); |
||||
} |
||||
mu_.Unlock(); |
||||
auto* tx_receiver = |
||||
static_cast<PersistentFakeTransactionReceiver*>(target->owner); |
||||
auto parcel = absl::make_unique<FakeReadableParcel>(std::move(data)); |
||||
tx_receiver->Receive(tx_code, parcel.get()).IgnoreError(); |
||||
} |
||||
Flush(); |
||||
} |
||||
|
||||
absl::Duration TransactionProcessor::GetRandomDelay() { |
||||
int64_t delay = |
||||
absl::Uniform<int64_t>(bit_gen_, delay_nsec_ / 2, delay_nsec_); |
||||
return absl::Nanoseconds(delay); |
||||
} |
||||
|
||||
void TransactionProcessor::EnQueueTransaction(FakeEndpoint* target, |
||||
BinderTransportTxCode tx_code, |
||||
FakeData data) { |
||||
grpc_core::MutexLock lock(&mu_); |
||||
if (tx_queue_.empty()) { |
||||
// This is the first transaction in the queue. Compute its deliver time.
|
||||
deliver_time_ = absl::Now() + GetRandomDelay(); |
||||
} |
||||
tx_queue_.emplace(target, tx_code, std::move(data)); |
||||
} |
||||
|
||||
FakeBinderTunnel::FakeBinderTunnel() |
||||
: send_endpoint_(absl::make_unique<FakeEndpoint>(this)), |
||||
recv_endpoint_(absl::make_unique<FakeEndpoint>(this)) { |
||||
send_endpoint_->other_end = recv_endpoint_.get(); |
||||
recv_endpoint_->other_end = send_endpoint_.get(); |
||||
} |
||||
|
||||
std::pair<std::unique_ptr<Binder>, std::unique_ptr<TransactionReceiver>> |
||||
NewBinderPair(TransactionReceiver::OnTransactCb transact_cb) { |
||||
auto tx_receiver = absl::make_unique<FakeTransactionReceiver>( |
||||
nullptr, std::move(transact_cb)); |
||||
std::unique_ptr<Binder> sender = tx_receiver->GetSender(); |
||||
return std::make_pair(std::move(sender), std::move(tx_receiver)); |
||||
} |
||||
|
||||
} // namespace end2end_testing
|
||||
} // namespace grpc_binder
|
||||
@ -0,0 +1,294 @@ |
||||
// Copyright 2021 gRPC authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// A collection of fake objects that offers in-memory simulation of data
|
||||
// transmission from one binder to another.
|
||||
//
|
||||
// Once the implementation of Binder is changed from BinderAndroid to
|
||||
// FakeBinder, we'll be able to test and fuzz our end-to-end binder transport in
|
||||
// a non-Android environment.
|
||||
//
|
||||
// The following diagram shows the high-level overview of how the in-memory
|
||||
// simulation works (FakeReceiver means FakeTransactionReceiver).
|
||||
//
|
||||
// thread boundary
|
||||
// |
|
||||
// |
|
||||
// ---------------- ---------------- | receive
|
||||
// | FakeBinder | | FakeReceiver | <--|----------------
|
||||
// ---------------- ---------------- | |
|
||||
// | ^ | ------------------------
|
||||
// | endpoint owner | | | TransactionProcessor |
|
||||
// | | | ------------------------
|
||||
// v | | ^
|
||||
// ---------------- ---------------- | |
|
||||
// | FakeEndpoint | --------> | FakeEndpoint | ---|----------------
|
||||
// ---------------- other_end ---------------- | enqueue
|
||||
// | ^ ^ | |
|
||||
// | | recv_endpoint | | |
|
||||
// | | | |
|
||||
// | | send_endpoint | |
|
||||
// v | | v
|
||||
// -------------------------------------------
|
||||
// | FakeBinderTunnel |
|
||||
// -------------------------------------------
|
||||
|
||||
#ifndef GRPC_TEST_CORE_TRANSPORT_BINDER_END2END_FAKE_BINDER_H |
||||
#define GRPC_TEST_CORE_TRANSPORT_BINDER_END2END_FAKE_BINDER_H |
||||
|
||||
#include <atomic> |
||||
#include <forward_list> |
||||
#include <memory> |
||||
#include <queue> |
||||
#include <string> |
||||
#include <thread> |
||||
#include <tuple> |
||||
#include <utility> |
||||
#include <vector> |
||||
|
||||
#include "absl/memory/memory.h" |
||||
#include "absl/random/random.h" |
||||
#include "absl/strings/str_format.h" |
||||
#include "absl/strings/string_view.h" |
||||
#include "absl/time/time.h" |
||||
#include "absl/types/variant.h" |
||||
#include "src/core/ext/transport/binder/wire_format/binder.h" |
||||
#include "src/core/ext/transport/binder/wire_format/wire_reader.h" |
||||
#include "src/core/lib/gprpp/sync.h" |
||||
#include "src/core/lib/gprpp/thd.h" |
||||
|
||||
namespace grpc_binder { |
||||
namespace end2end_testing { |
||||
|
||||
using FakeData = std::vector< |
||||
absl::variant<int32_t, void*, std::string, std::vector<int8_t>>>; |
||||
|
||||
// A fake writable parcel.
|
||||
//
|
||||
// It simulates the functionalities of a real writable parcel and stores all
|
||||
// written data in memory. The data can then be transferred by calling
|
||||
// MoveData().
|
||||
class FakeWritableParcel final : public WritableParcel { |
||||
public: |
||||
FakeWritableParcel(); |
||||
int32_t GetDataPosition() const override; |
||||
absl::Status SetDataPosition(int32_t pos) override; |
||||
absl::Status WriteInt32(int32_t data) override; |
||||
absl::Status WriteBinder(HasRawBinder* binder) override; |
||||
absl::Status WriteString(absl::string_view s) override; |
||||
absl::Status WriteByteArray(const int8_t* buffer, int32_t length) override; |
||||
|
||||
FakeData MoveData() { return std::move(data_); } |
||||
|
||||
private: |
||||
FakeData data_; |
||||
size_t data_position_ = 0; |
||||
}; |
||||
|
||||
// A fake readable parcel.
|
||||
//
|
||||
// It takes in the data transferred from a FakeWritableParcel and provides
|
||||
// methods to retrieve those data in the receiving end.
|
||||
class FakeReadableParcel final : public ReadableParcel { |
||||
public: |
||||
explicit FakeReadableParcel(FakeData data) : data_(std::move(data)) {} |
||||
absl::Status ReadInt32(int32_t* data) const override; |
||||
absl::Status ReadBinder(std::unique_ptr<Binder>* data) const override; |
||||
absl::Status ReadByteArray(std::string* data) const override; |
||||
absl::Status ReadString(char data[111]) const override; |
||||
|
||||
private: |
||||
const FakeData data_; |
||||
mutable size_t data_position_ = 0; |
||||
}; |
||||
|
||||
class FakeBinder; |
||||
class FakeBinderTunnel; |
||||
|
||||
// FakeEndpoint is a simple struct that holds the pointer to the other end, a
|
||||
// pointer to the tunnel and a pointer to its owner. This tells the owner where
|
||||
// the data should be sent.
|
||||
struct FakeEndpoint { |
||||
explicit FakeEndpoint(FakeBinderTunnel* tunnel) : tunnel(tunnel) {} |
||||
|
||||
FakeEndpoint* other_end; |
||||
FakeBinderTunnel* tunnel; |
||||
// The owner is either a FakeBinder (the sending part) or a
|
||||
// FakeTransactionReceiver (the receiving part). Both parts hold an endpoint
|
||||
// with |owner| pointing back to them and |other_end| pointing to each other.
|
||||
void* owner; |
||||
}; |
||||
|
||||
class PersistentFakeTransactionReceiver; |
||||
|
||||
// A fake transaction receiver.
|
||||
//
|
||||
// This is the receiving part of a pair of binders. When constructed, a binder
|
||||
// tunnle is created, and the sending part can be retrieved by calling
|
||||
// GetSender().
|
||||
//
|
||||
// It also provides a Receive() function to simulate the on-transaction
|
||||
// callback of a real Android binder.
|
||||
class FakeTransactionReceiver : public TransactionReceiver { |
||||
public: |
||||
FakeTransactionReceiver(grpc_core::RefCountedPtr<WireReader> wire_reader_ref, |
||||
TransactionReceiver::OnTransactCb cb); |
||||
|
||||
void* GetRawBinder() override; |
||||
|
||||
std::unique_ptr<Binder> GetSender() const; |
||||
|
||||
private: |
||||
PersistentFakeTransactionReceiver* persistent_tx_receiver_; |
||||
}; |
||||
|
||||
// A "persistent" version of the FakeTransactionReceiver. That is, its lifetime
|
||||
// is managed by the processor and it outlives the wire reader and
|
||||
// grpc_binder_transport, so we can safely dereference a pointer to it in
|
||||
// ProcessLoop().
|
||||
class PersistentFakeTransactionReceiver { |
||||
public: |
||||
PersistentFakeTransactionReceiver( |
||||
grpc_core::RefCountedPtr<WireReader> wire_reader_ref, |
||||
TransactionReceiver::OnTransactCb cb, |
||||
std::unique_ptr<FakeBinderTunnel> tunnel); |
||||
|
||||
absl::Status Receive(BinderTransportTxCode tx_code, |
||||
const ReadableParcel* parcel) { |
||||
return callback_(static_cast<transaction_code_t>(tx_code), parcel); |
||||
} |
||||
|
||||
private: |
||||
grpc_core::RefCountedPtr<WireReader> wire_reader_ref_; |
||||
TransactionReceiver::OnTransactCb callback_; |
||||
std::unique_ptr<FakeBinderTunnel> tunnel_; |
||||
|
||||
friend class FakeTransactionReceiver; |
||||
}; |
||||
|
||||
// The sending part of a binders pair. It provides a FakeWritableParcel to the
|
||||
// user, and when Transact() is called, it transfers the written data to the
|
||||
// other end of the tunnel by following the information in its endpoint.
|
||||
class FakeBinder final : public Binder { |
||||
public: |
||||
explicit FakeBinder(FakeEndpoint* endpoint) : endpoint_(endpoint) { |
||||
endpoint_->owner = this; |
||||
} |
||||
|
||||
void Initialize() override {} |
||||
absl::Status PrepareTransaction() override { |
||||
input_ = absl::make_unique<FakeWritableParcel>(); |
||||
return absl::OkStatus(); |
||||
} |
||||
|
||||
absl::Status Transact(BinderTransportTxCode tx_code) override; |
||||
|
||||
WritableParcel* GetWritableParcel() const override { return input_.get(); } |
||||
ReadableParcel* GetReadableParcel() const override { return output_.get(); } |
||||
|
||||
std::unique_ptr<TransactionReceiver> ConstructTxReceiver( |
||||
grpc_core::RefCountedPtr<WireReader> wire_reader_ref, |
||||
TransactionReceiver::OnTransactCb transact_cb) const override; |
||||
|
||||
void* GetRawBinder() override { return endpoint_->other_end; } |
||||
|
||||
private: |
||||
FakeEndpoint* endpoint_; |
||||
std::unique_ptr<FakeWritableParcel> input_; |
||||
std::unique_ptr<FakeReadableParcel> output_; |
||||
}; |
||||
|
||||
// A transaction processor.
|
||||
//
|
||||
// Once constructed, it'll create a another thread that deliver in-coming
|
||||
// transactions to their destinations.
|
||||
class TransactionProcessor { |
||||
public: |
||||
explicit TransactionProcessor(absl::Duration delay = absl::ZeroDuration()); |
||||
~TransactionProcessor() { Terminate(); } |
||||
|
||||
void SetDelay(absl::Duration delay); |
||||
|
||||
void Terminate(); |
||||
void ProcessLoop(); |
||||
void Flush(); |
||||
|
||||
// Issue a transaction with |target| pointing to the target endpoint. The
|
||||
// transactions will be delivered in the same order they're issued, possibly
|
||||
// with random delay to simulate real-world situation.
|
||||
void EnQueueTransaction(FakeEndpoint* target, BinderTransportTxCode tx_code, |
||||
FakeData data); |
||||
|
||||
PersistentFakeTransactionReceiver& NewPersistentTxReceiver( |
||||
grpc_core::RefCountedPtr<WireReader> wire_reader_ref, |
||||
TransactionReceiver::OnTransactCb cb, |
||||
std::unique_ptr<FakeBinderTunnel> tunnel) { |
||||
grpc_core::MutexLock lock(&tx_receiver_mu_); |
||||
storage_.emplace_front(wire_reader_ref, cb, std::move(tunnel)); |
||||
return storage_.front(); |
||||
} |
||||
|
||||
private: |
||||
absl::Duration GetRandomDelay(); |
||||
void WaitForNextTransaction() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_); |
||||
|
||||
grpc_core::Mutex mu_; |
||||
std::queue<std::tuple<FakeEndpoint*, BinderTransportTxCode, FakeData>> |
||||
tx_queue_ ABSL_GUARDED_BY(mu_); |
||||
absl::Time deliver_time_ ABSL_GUARDED_BY(mu_); |
||||
int64_t delay_nsec_; |
||||
absl::BitGen bit_gen_; |
||||
grpc_core::Thread tx_thread_; |
||||
std::atomic<bool> terminated_; |
||||
|
||||
grpc_core::Mutex tx_receiver_mu_; |
||||
// Use forward_list to avoid invalid pointers resulted by reallocation in
|
||||
// containers such as std::vector.
|
||||
std::forward_list<PersistentFakeTransactionReceiver> storage_ |
||||
ABSL_GUARDED_BY(tx_receiver_mu_); |
||||
}; |
||||
|
||||
// The global (shared) processor. Test suite should be responsible of
|
||||
// creating/deleting it.
|
||||
extern TransactionProcessor* g_transaction_processor; |
||||
|
||||
// A binder tunnel.
|
||||
//
|
||||
// It is a simple helper that creates and links two endpoints.
|
||||
class FakeBinderTunnel { |
||||
public: |
||||
FakeBinderTunnel(); |
||||
|
||||
void EnQueueTransaction(FakeEndpoint* target, BinderTransportTxCode tx_code, |
||||
FakeData data) { |
||||
g_transaction_processor->EnQueueTransaction(target, tx_code, |
||||
std::move(data)); |
||||
} |
||||
|
||||
FakeEndpoint* GetSendEndpoint() const { return send_endpoint_.get(); } |
||||
FakeEndpoint* GetRecvEndpoint() const { return recv_endpoint_.get(); } |
||||
|
||||
private: |
||||
std::unique_ptr<FakeEndpoint> send_endpoint_; |
||||
std::unique_ptr<FakeEndpoint> recv_endpoint_; |
||||
}; |
||||
|
||||
// A helper function for constructing a pair of connected binders.
|
||||
std::pair<std::unique_ptr<Binder>, std::unique_ptr<TransactionReceiver>> |
||||
NewBinderPair(TransactionReceiver::OnTransactCb transact_cb); |
||||
|
||||
} // namespace end2end_testing
|
||||
} // namespace grpc_binder
|
||||
|
||||
#endif // GRPC_TEST_CORE_TRANSPORT_BINDER_END2END_FAKE_BINDER_H
|
||||
@ -0,0 +1,373 @@ |
||||
// Copyright 2021 gRPC authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "test/core/transport/binder/end2end/fake_binder.h" |
||||
|
||||
#include <gmock/gmock.h> |
||||
#include <gtest/gtest.h> |
||||
#include <algorithm> |
||||
#include <random> |
||||
#include <string> |
||||
#include <utility> |
||||
|
||||
#include "absl/strings/str_format.h" |
||||
#include "absl/time/time.h" |
||||
#include "test/core/util/test_config.h" |
||||
|
||||
namespace grpc_binder { |
||||
namespace end2end_testing { |
||||
|
||||
TEST(FakeBinderTestWithoutTransaction, WritableParcelDataPosition) { |
||||
std::unique_ptr<WritableParcel> parcel = |
||||
absl::make_unique<FakeWritableParcel>(); |
||||
EXPECT_EQ(parcel->GetDataPosition(), 0); |
||||
EXPECT_TRUE(parcel->WriteInt32(0).ok()); |
||||
EXPECT_EQ(parcel->GetDataPosition(), 1); |
||||
EXPECT_TRUE(parcel->WriteInt32(1).ok()); |
||||
EXPECT_TRUE(parcel->WriteInt32(2).ok()); |
||||
EXPECT_EQ(parcel->GetDataPosition(), 3); |
||||
EXPECT_TRUE(parcel->WriteString("").ok()); |
||||
EXPECT_EQ(parcel->GetDataPosition(), 4); |
||||
EXPECT_TRUE(parcel->SetDataPosition(0).ok()); |
||||
const char kBuffer[] = "test"; |
||||
EXPECT_TRUE(parcel |
||||
->WriteByteArray(reinterpret_cast<const int8_t*>(kBuffer), |
||||
strlen(kBuffer)) |
||||
.ok()); |
||||
EXPECT_EQ(parcel->GetDataPosition(), 1); |
||||
EXPECT_TRUE(parcel->SetDataPosition(100).ok()); |
||||
EXPECT_EQ(parcel->GetDataPosition(), 100); |
||||
} |
||||
|
||||
namespace { |
||||
|
||||
class FakeBinderTest : public ::testing::TestWithParam<absl::Duration> { |
||||
public: |
||||
FakeBinderTest() { |
||||
g_transaction_processor = new TransactionProcessor(GetParam()); |
||||
} |
||||
~FakeBinderTest() override { delete g_transaction_processor; } |
||||
}; |
||||
|
||||
} // namespace
|
||||
|
||||
TEST_P(FakeBinderTest, SendInt32) { |
||||
constexpr int kValue = 0x1234; |
||||
constexpr int kTxCode = 0x4321; |
||||
int called = 0; |
||||
std::unique_ptr<Binder> sender; |
||||
std::unique_ptr<TransactionReceiver> tx_receiver; |
||||
std::tie(sender, tx_receiver) = NewBinderPair( |
||||
[&](transaction_code_t tx_code, const ReadableParcel* parcel) { |
||||
EXPECT_EQ(tx_code, kTxCode); |
||||
int value = 0; |
||||
EXPECT_TRUE(parcel->ReadInt32(&value).ok()); |
||||
EXPECT_EQ(value, kValue); |
||||
called++; |
||||
return absl::OkStatus(); |
||||
}); |
||||
|
||||
EXPECT_TRUE(sender->PrepareTransaction().ok()); |
||||
WritableParcel* parcel = sender->GetWritableParcel(); |
||||
EXPECT_TRUE(parcel->WriteInt32(kValue).ok()); |
||||
EXPECT_TRUE(sender->Transact(BinderTransportTxCode(kTxCode)).ok()); |
||||
|
||||
g_transaction_processor->Terminate(); |
||||
EXPECT_EQ(called, 1); |
||||
} |
||||
|
||||
TEST_P(FakeBinderTest, SendString) { |
||||
constexpr char kValue[] = "example-string"; |
||||
constexpr int kTxCode = 0x4321; |
||||
int called = 0; |
||||
std::unique_ptr<Binder> sender; |
||||
std::unique_ptr<TransactionReceiver> tx_receiver; |
||||
std::tie(sender, tx_receiver) = NewBinderPair( |
||||
[&](transaction_code_t tx_code, const ReadableParcel* parcel) { |
||||
EXPECT_EQ(tx_code, kTxCode); |
||||
char value[111]; |
||||
memset(value, 0, sizeof(value)); |
||||
EXPECT_TRUE(parcel->ReadString(value).ok()); |
||||
EXPECT_STREQ(value, kValue); |
||||
called++; |
||||
return absl::OkStatus(); |
||||
}); |
||||
|
||||
EXPECT_TRUE(sender->PrepareTransaction().ok()); |
||||
WritableParcel* parcel = sender->GetWritableParcel(); |
||||
EXPECT_TRUE(parcel->WriteString(kValue).ok()); |
||||
EXPECT_TRUE(sender->Transact(BinderTransportTxCode(kTxCode)).ok()); |
||||
|
||||
g_transaction_processor->Terminate(); |
||||
EXPECT_EQ(called, 1); |
||||
} |
||||
|
||||
TEST_P(FakeBinderTest, SendByteArray) { |
||||
constexpr char kValue[] = "example-byte-array"; |
||||
constexpr int kTxCode = 0x4321; |
||||
int called = 0; |
||||
std::unique_ptr<Binder> sender; |
||||
std::unique_ptr<TransactionReceiver> tx_receiver; |
||||
std::tie(sender, tx_receiver) = NewBinderPair( |
||||
[&](transaction_code_t tx_code, const ReadableParcel* parcel) { |
||||
EXPECT_EQ(tx_code, kTxCode); |
||||
std::string value; |
||||
EXPECT_TRUE(parcel->ReadByteArray(&value).ok()); |
||||
EXPECT_EQ(value, kValue); |
||||
called++; |
||||
return absl::OkStatus(); |
||||
}); |
||||
|
||||
EXPECT_TRUE(sender->PrepareTransaction().ok()); |
||||
WritableParcel* parcel = sender->GetWritableParcel(); |
||||
EXPECT_TRUE(parcel |
||||
->WriteByteArray(reinterpret_cast<const int8_t*>(kValue), |
||||
strlen(kValue)) |
||||
.ok()); |
||||
EXPECT_TRUE(sender->Transact(BinderTransportTxCode(kTxCode)).ok()); |
||||
|
||||
g_transaction_processor->Terminate(); |
||||
EXPECT_EQ(called, 1); |
||||
} |
||||
|
||||
TEST_P(FakeBinderTest, SendMultipleItems) { |
||||
constexpr char kByteArray[] = "example-byte-array"; |
||||
constexpr char kString[] = "example-string"; |
||||
constexpr int kValue = 0x1234; |
||||
constexpr int kTxCode = 0x4321; |
||||
int called = 0; |
||||
std::unique_ptr<Binder> sender; |
||||
std::unique_ptr<TransactionReceiver> tx_receiver; |
||||
std::tie(sender, tx_receiver) = NewBinderPair( |
||||
[&](transaction_code_t tx_code, const ReadableParcel* parcel) { |
||||
int value_result; |
||||
EXPECT_EQ(tx_code, kTxCode); |
||||
EXPECT_TRUE(parcel->ReadInt32(&value_result).ok()); |
||||
EXPECT_EQ(value_result, kValue); |
||||
std::string byte_array_result; |
||||
EXPECT_TRUE(parcel->ReadByteArray(&byte_array_result).ok()); |
||||
EXPECT_EQ(byte_array_result, kByteArray); |
||||
char string_result[111]; |
||||
memset(string_result, 0, sizeof(string_result)); |
||||
EXPECT_TRUE(parcel->ReadString(string_result).ok()); |
||||
EXPECT_STREQ(string_result, kString); |
||||
called++; |
||||
return absl::OkStatus(); |
||||
}); |
||||
|
||||
EXPECT_TRUE(sender->PrepareTransaction().ok()); |
||||
WritableParcel* parcel = sender->GetWritableParcel(); |
||||
EXPECT_TRUE(parcel->WriteInt32(kValue).ok()); |
||||
EXPECT_TRUE(parcel |
||||
->WriteByteArray(reinterpret_cast<const int8_t*>(kByteArray), |
||||
strlen(kByteArray)) |
||||
.ok()); |
||||
EXPECT_TRUE(parcel->WriteString(kString).ok()); |
||||
EXPECT_TRUE(sender->Transact(BinderTransportTxCode(kTxCode)).ok()); |
||||
|
||||
g_transaction_processor->Terminate(); |
||||
EXPECT_EQ(called, 1); |
||||
} |
||||
|
||||
TEST_P(FakeBinderTest, SendBinder) { |
||||
constexpr int kValue = 0x1234; |
||||
constexpr int kTxCode = 0x4321; |
||||
int called = 0; |
||||
std::unique_ptr<Binder> sender; |
||||
std::unique_ptr<TransactionReceiver> tx_receiver; |
||||
std::tie(sender, tx_receiver) = NewBinderPair( |
||||
[&](transaction_code_t tx_code, const ReadableParcel* parcel) { |
||||
EXPECT_EQ(tx_code, kTxCode); |
||||
std::unique_ptr<Binder> binder; |
||||
EXPECT_TRUE(parcel->ReadBinder(&binder).ok()); |
||||
EXPECT_TRUE(binder->PrepareTransaction().ok()); |
||||
WritableParcel* writable_parcel = binder->GetWritableParcel(); |
||||
EXPECT_TRUE(writable_parcel->WriteInt32(kValue).ok()); |
||||
EXPECT_TRUE(binder->Transact(BinderTransportTxCode(kTxCode + 1)).ok()); |
||||
called++; |
||||
return absl::OkStatus(); |
||||
}); |
||||
|
||||
int called2 = 0; |
||||
std::unique_ptr<TransactionReceiver> tx_receiver2 = |
||||
absl::make_unique<FakeTransactionReceiver>( |
||||
nullptr, |
||||
[&](transaction_code_t tx_code, const ReadableParcel* parcel) { |
||||
int value; |
||||
EXPECT_TRUE(parcel->ReadInt32(&value).ok()); |
||||
EXPECT_EQ(value, kValue); |
||||
EXPECT_EQ(tx_code, kTxCode + 1); |
||||
called2++; |
||||
return absl::OkStatus(); |
||||
}); |
||||
EXPECT_TRUE(sender->PrepareTransaction().ok()); |
||||
WritableParcel* parcel = sender->GetWritableParcel(); |
||||
EXPECT_TRUE(parcel->WriteBinder(tx_receiver2.get()).ok()); |
||||
EXPECT_TRUE(sender->Transact(BinderTransportTxCode(kTxCode)).ok()); |
||||
|
||||
g_transaction_processor->Terminate(); |
||||
EXPECT_EQ(called, 1); |
||||
EXPECT_EQ(called2, 1); |
||||
} |
||||
|
||||
TEST_P(FakeBinderTest, SendTransactionAfterDestruction) { |
||||
constexpr int kValue = 0x1234; |
||||
constexpr int kTxCode = 0x4321; |
||||
std::unique_ptr<Binder> sender; |
||||
int called = 0; |
||||
{ |
||||
std::unique_ptr<TransactionReceiver> tx_receiver; |
||||
std::tie(sender, tx_receiver) = NewBinderPair( |
||||
[&](transaction_code_t tx_code, const ReadableParcel* parcel) { |
||||
EXPECT_EQ(tx_code, kTxCode); |
||||
int value; |
||||
EXPECT_TRUE(parcel->ReadInt32(&value).ok()); |
||||
EXPECT_EQ(value, kValue + called); |
||||
called++; |
||||
return absl::OkStatus(); |
||||
}); |
||||
EXPECT_TRUE(sender->PrepareTransaction().ok()); |
||||
WritableParcel* parcel = sender->GetWritableParcel(); |
||||
EXPECT_TRUE(parcel->WriteInt32(kValue).ok()); |
||||
EXPECT_TRUE(sender->Transact(BinderTransportTxCode(kTxCode)).ok()); |
||||
} |
||||
// tx_receiver gets destructed here. This additional transaction should
|
||||
// *still* be received.
|
||||
EXPECT_TRUE(sender->PrepareTransaction().ok()); |
||||
WritableParcel* parcel = sender->GetWritableParcel(); |
||||
EXPECT_TRUE(parcel->WriteInt32(kValue + 1).ok()); |
||||
EXPECT_TRUE(sender->Transact(BinderTransportTxCode(kTxCode)).ok()); |
||||
|
||||
g_transaction_processor->Terminate(); |
||||
EXPECT_EQ(called, 2); |
||||
} |
||||
|
||||
namespace { |
||||
|
||||
struct ThreadArgument { |
||||
int tid; |
||||
std::vector<std::vector<std::pair<std::unique_ptr<Binder>, |
||||
std::unique_ptr<TransactionReceiver>>>>* |
||||
global_binder_pairs; |
||||
std::vector<std::vector<int>>* global_cnts; |
||||
int tx_code; |
||||
int num_pairs_per_thread; |
||||
int num_transactions_per_pair; |
||||
grpc_core::Mutex* mu; |
||||
}; |
||||
|
||||
} // namespace
|
||||
|
||||
// Verify that this system works correctly in a concurrent environment.
|
||||
//
|
||||
// In end-to-end tests, there will be at least two threads, one from client to
|
||||
// server and vice versa. Thus, it's important for us to make sure that the
|
||||
// simulation is correct in such setup.
|
||||
TEST_P(FakeBinderTest, StressTest) { |
||||
constexpr int kTxCode = 0x4321; |
||||
constexpr int kNumThreads = 16; |
||||
constexpr int kNumPairsPerThread = 128; |
||||
constexpr int kNumTransactionsPerPair = 128; |
||||
std::vector<ThreadArgument> args(kNumThreads); |
||||
|
||||
grpc_core::Mutex mu; |
||||
std::vector<std::vector< |
||||
std::pair<std::unique_ptr<Binder>, std::unique_ptr<TransactionReceiver>>>> |
||||
global_binder_pairs(kNumThreads); |
||||
std::vector<std::vector<int>> global_cnts( |
||||
kNumThreads, std::vector<int>(kNumPairsPerThread, 0)); |
||||
|
||||
auto th_function = [](void* arg) { |
||||
ThreadArgument* th_arg = static_cast<ThreadArgument*>(arg); |
||||
int tid = th_arg->tid; |
||||
std::vector<std::pair<std::unique_ptr<Binder>, |
||||
std::unique_ptr<TransactionReceiver>>> |
||||
binder_pairs; |
||||
for (int p = 0; p < th_arg->num_pairs_per_thread; ++p) { |
||||
std::unique_ptr<Binder> binder; |
||||
std::unique_ptr<TransactionReceiver> tx_receiver; |
||||
int expected_tx_code = th_arg->tx_code; |
||||
std::vector<std::vector<int>>* cnt = th_arg->global_cnts; |
||||
std::tie(binder, tx_receiver) = |
||||
NewBinderPair([tid, p, cnt, expected_tx_code]( |
||||
transaction_code_t tx_code, |
||||
const ReadableParcel* parcel) mutable { |
||||
EXPECT_EQ(tx_code, expected_tx_code); |
||||
int value; |
||||
EXPECT_TRUE(parcel->ReadInt32(&value).ok()); |
||||
EXPECT_EQ(tid, value); |
||||
EXPECT_TRUE(parcel->ReadInt32(&value).ok()); |
||||
EXPECT_EQ(p, value); |
||||
EXPECT_TRUE(parcel->ReadInt32(&value).ok()); |
||||
EXPECT_EQ((*cnt)[tid][p], value); |
||||
(*cnt)[tid][p]++; |
||||
return absl::OkStatus(); |
||||
}); |
||||
binder_pairs.emplace_back(std::move(binder), std::move(tx_receiver)); |
||||
} |
||||
std::vector<int> order; |
||||
for (int i = 0; i < th_arg->num_pairs_per_thread; ++i) { |
||||
for (int j = 0; j < th_arg->num_transactions_per_pair; ++j) { |
||||
order.emplace_back(i); |
||||
} |
||||
} |
||||
std::mt19937 rng(tid); |
||||
std::shuffle(order.begin(), order.end(), rng); |
||||
std::vector<int> tx_cnt(th_arg->num_pairs_per_thread); |
||||
for (int p : order) { |
||||
EXPECT_TRUE(binder_pairs[p].first->PrepareTransaction().ok()); |
||||
WritableParcel* parcel = binder_pairs[p].first->GetWritableParcel(); |
||||
EXPECT_TRUE(parcel->WriteInt32(th_arg->tid).ok()); |
||||
EXPECT_TRUE(parcel->WriteInt32(p).ok()); |
||||
EXPECT_TRUE(parcel->WriteInt32(tx_cnt[p]++).ok()); |
||||
EXPECT_TRUE(binder_pairs[p] |
||||
.first->Transact(BinderTransportTxCode(th_arg->tx_code)) |
||||
.ok()); |
||||
} |
||||
th_arg->mu->Lock(); |
||||
(*th_arg->global_binder_pairs)[tid] = std::move(binder_pairs); |
||||
th_arg->mu->Unlock(); |
||||
}; |
||||
|
||||
std::vector<grpc_core::Thread> thrs(kNumThreads); |
||||
std::vector<std::string> thr_names(kNumThreads); |
||||
for (int i = 0; i < kNumThreads; ++i) { |
||||
args[i].tid = i; |
||||
args[i].global_binder_pairs = &global_binder_pairs; |
||||
args[i].global_cnts = &global_cnts; |
||||
args[i].tx_code = kTxCode; |
||||
args[i].num_pairs_per_thread = kNumPairsPerThread; |
||||
args[i].num_transactions_per_pair = kNumTransactionsPerPair; |
||||
args[i].mu = μ |
||||
thr_names[i] = absl::StrFormat("thread-%d", i); |
||||
thrs[i] = grpc_core::Thread(thr_names[i].c_str(), th_function, &args[i]); |
||||
} |
||||
for (auto& th : thrs) th.Start(); |
||||
for (auto& th : thrs) th.Join(); |
||||
g_transaction_processor->Terminate(); |
||||
} |
||||
|
||||
INSTANTIATE_TEST_SUITE_P(FakeBinderTestWithDifferentDelayTimes, FakeBinderTest, |
||||
testing::Values(absl::ZeroDuration(), |
||||
absl::Nanoseconds(10), |
||||
absl::Microseconds(10))); |
||||
|
||||
} // namespace end2end_testing
|
||||
} // namespace grpc_binder
|
||||
|
||||
int main(int argc, char** argv) { |
||||
::testing::InitGoogleTest(&argc, argv); |
||||
grpc::testing::TestEnvironment env(argc, argv); |
||||
return RUN_ALL_TESTS(); |
||||
} |
||||
@ -0,0 +1,126 @@ |
||||
// Copyright 2021 gRPC authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "test/core/transport/binder/end2end/testing_channel_create.h" |
||||
|
||||
#include <utility> |
||||
|
||||
#include "src/core/ext/transport/binder/transport/binder_transport.h" |
||||
#include "src/core/ext/transport/binder/wire_format/wire_reader_impl.h" |
||||
#include "src/core/lib/channel/channel_args.h" |
||||
#include "src/core/lib/surface/channel.h" |
||||
#include "src/core/lib/transport/error_utils.h" |
||||
|
||||
namespace grpc_binder { |
||||
namespace end2end_testing { |
||||
|
||||
namespace { |
||||
// Since we assume the first half of the transport setup is completed before the
|
||||
// server side enters WireReader::SetupTransport, we need this helper to wait
|
||||
// and finish that part of the negotiation for us.
|
||||
class ServerSetupTransportHelper { |
||||
public: |
||||
ServerSetupTransportHelper() |
||||
: wire_reader_(absl::make_unique<WireReaderImpl>( |
||||
/*transport_stream_receiver=*/nullptr, /*is_client=*/false)) { |
||||
std::tie(endpoint_binder_, tx_receiver_) = NewBinderPair( |
||||
[this](transaction_code_t tx_code, const ReadableParcel* parcel) { |
||||
return this->wire_reader_->ProcessTransaction(tx_code, parcel); |
||||
}); |
||||
} |
||||
std::unique_ptr<Binder> WaitForClientBinder() { |
||||
return wire_reader_->RecvSetupTransport(); |
||||
} |
||||
|
||||
std::unique_ptr<Binder> GetEndpointBinderForClient() { |
||||
return std::move(endpoint_binder_); |
||||
} |
||||
|
||||
private: |
||||
std::unique_ptr<WireReaderImpl> wire_reader_; |
||||
// The endpoint binder for client.
|
||||
std::unique_ptr<Binder> endpoint_binder_; |
||||
std::unique_ptr<TransactionReceiver> tx_receiver_; |
||||
}; |
||||
} // namespace
|
||||
|
||||
std::pair<grpc_transport*, grpc_transport*> |
||||
CreateClientServerBindersPairForTesting() { |
||||
ServerSetupTransportHelper helper; |
||||
std::unique_ptr<Binder> endpoint_binder = helper.GetEndpointBinderForClient(); |
||||
grpc_transport* client_transport = nullptr; |
||||
|
||||
struct ThreadArgs { |
||||
std::unique_ptr<Binder> endpoint_binder; |
||||
grpc_transport** client_transport; |
||||
} args; |
||||
|
||||
args.endpoint_binder = std::move(endpoint_binder); |
||||
args.client_transport = &client_transport; |
||||
|
||||
grpc_core::Thread client_thread( |
||||
"client-thread", |
||||
[](void* arg) { |
||||
ThreadArgs* args = static_cast<ThreadArgs*>(arg); |
||||
std::unique_ptr<Binder> endpoint_binder = |
||||
std::move(args->endpoint_binder); |
||||
*args->client_transport = |
||||
grpc_create_binder_transport_client(std::move(endpoint_binder)); |
||||
}, |
||||
&args); |
||||
client_thread.Start(); |
||||
grpc_transport* server_transport = |
||||
grpc_create_binder_transport_server(helper.WaitForClientBinder()); |
||||
client_thread.Join(); |
||||
return std::make_pair(client_transport, server_transport); |
||||
} |
||||
|
||||
std::shared_ptr<grpc::Channel> BinderChannelForTesting( |
||||
grpc::Server* server, const grpc::ChannelArguments& args) { |
||||
grpc_channel_args channel_args = args.c_channel_args(); |
||||
return grpc::CreateChannelInternal( |
||||
"", |
||||
grpc_binder_channel_create_for_testing(server->c_server(), &channel_args, |
||||
nullptr), |
||||
std::vector<std::unique_ptr< |
||||
grpc::experimental::ClientInterceptorFactoryInterface>>()); |
||||
} |
||||
|
||||
} // namespace end2end_testing
|
||||
} // namespace grpc_binder
|
||||
|
||||
grpc_channel* grpc_binder_channel_create_for_testing(grpc_server* server, |
||||
grpc_channel_args* args, |
||||
void* /*reserved*/) { |
||||
grpc_core::ExecCtx exec_ctx; |
||||
|
||||
grpc_arg default_authority_arg = grpc_channel_arg_string_create( |
||||
const_cast<char*>(GRPC_ARG_DEFAULT_AUTHORITY), |
||||
const_cast<char*>("test.authority")); |
||||
grpc_channel_args* client_args = |
||||
grpc_channel_args_copy_and_add(args, &default_authority_arg, 1); |
||||
|
||||
grpc_transport *client_transport, *server_transport; |
||||
std::tie(client_transport, server_transport) = |
||||
grpc_binder::end2end_testing::CreateClientServerBindersPairForTesting(); |
||||
grpc_error_handle error = server->core_server->SetupTransport( |
||||
server_transport, nullptr, args, nullptr); |
||||
GPR_ASSERT(error == GRPC_ERROR_NONE); |
||||
grpc_channel* channel = |
||||
grpc_channel_create("binder", client_args, GRPC_CLIENT_DIRECT_CHANNEL, |
||||
client_transport, nullptr, 0, &error); |
||||
GPR_ASSERT(error == GRPC_ERROR_NONE); |
||||
grpc_channel_args_destroy(client_args); |
||||
return channel; |
||||
} |
||||
@ -0,0 +1,41 @@ |
||||
// Copyright 2021 gRPC authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#ifndef GRPC_TEST_CORE_TRANSPORT_BINDER_END2END_TESTING_CHANNEL_CREATE_H |
||||
#define GRPC_TEST_CORE_TRANSPORT_BINDER_END2END_TESTING_CHANNEL_CREATE_H |
||||
|
||||
#include <grpcpp/grpcpp.h> |
||||
#include <utility> |
||||
|
||||
#include "src/core/ext/transport/binder/transport/binder_transport.h" |
||||
#include "src/core/lib/surface/server.h" |
||||
#include "test/core/transport/binder/end2end/fake_binder.h" |
||||
|
||||
namespace grpc_binder { |
||||
namespace end2end_testing { |
||||
|
||||
std::pair<grpc_transport*, grpc_transport*> |
||||
CreateClientServerBindersPairForTesting(); |
||||
|
||||
std::shared_ptr<grpc::Channel> BinderChannelForTesting( |
||||
grpc::Server* server, const grpc::ChannelArguments& args); |
||||
|
||||
} // namespace end2end_testing
|
||||
} // namespace grpc_binder
|
||||
|
||||
grpc_channel* grpc_binder_channel_create_for_testing(grpc_server* server, |
||||
grpc_channel_args* args, |
||||
void* /*reserved*/); |
||||
|
||||
#endif // GRPC_TEST_CORE_TRANSPORT_BINDER_END2END_TESTING_CHANNEL_CREATE_H
|
||||
@ -0,0 +1,57 @@ |
||||
// Copyright 2021 gRPC authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "test/core/transport/binder/mock_objects.h" |
||||
|
||||
#include <memory> |
||||
|
||||
#include "absl/memory/memory.h" |
||||
|
||||
namespace grpc_binder { |
||||
|
||||
using ::testing::Return; |
||||
|
||||
MockReadableParcel::MockReadableParcel() { |
||||
ON_CALL(*this, ReadBinder).WillByDefault([](std::unique_ptr<Binder>* binder) { |
||||
*binder = absl::make_unique<MockBinder>(); |
||||
return absl::OkStatus(); |
||||
}); |
||||
ON_CALL(*this, ReadInt32).WillByDefault(Return(absl::OkStatus())); |
||||
ON_CALL(*this, ReadByteArray).WillByDefault(Return(absl::OkStatus())); |
||||
ON_CALL(*this, ReadString).WillByDefault(Return(absl::OkStatus())); |
||||
} |
||||
|
||||
MockWritableParcel::MockWritableParcel() { |
||||
ON_CALL(*this, SetDataPosition).WillByDefault(Return(absl::OkStatus())); |
||||
ON_CALL(*this, WriteInt32).WillByDefault(Return(absl::OkStatus())); |
||||
ON_CALL(*this, WriteBinder).WillByDefault(Return(absl::OkStatus())); |
||||
ON_CALL(*this, WriteString).WillByDefault(Return(absl::OkStatus())); |
||||
ON_CALL(*this, WriteByteArray).WillByDefault(Return(absl::OkStatus())); |
||||
} |
||||
|
||||
MockBinder::MockBinder() { |
||||
ON_CALL(*this, PrepareTransaction).WillByDefault(Return(absl::OkStatus())); |
||||
ON_CALL(*this, Transact).WillByDefault(Return(absl::OkStatus())); |
||||
ON_CALL(*this, GetWritableParcel).WillByDefault(Return(&mock_input_)); |
||||
ON_CALL(*this, GetReadableParcel).WillByDefault(Return(&mock_output_)); |
||||
ON_CALL(*this, ConstructTxReceiver) |
||||
.WillByDefault( |
||||
[this](grpc_core::RefCountedPtr<WireReader> /*wire_reader_ref*/, |
||||
TransactionReceiver::OnTransactCb cb) { |
||||
return absl::make_unique<MockTransactionReceiver>( |
||||
cb, BinderTransportTxCode::SETUP_TRANSPORT, &mock_output_); |
||||
}); |
||||
} |
||||
|
||||
} // namespace grpc_binder
|
||||
@ -0,0 +1,113 @@ |
||||
// Copyright 2021 gRPC authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#ifndef GRPC_TEST_CORE_TRANSPORT_BINDER_MOCK_OBJECTS_H |
||||
#define GRPC_TEST_CORE_TRANSPORT_BINDER_MOCK_OBJECTS_H |
||||
|
||||
#include <gmock/gmock.h> |
||||
|
||||
#include "src/core/ext/transport/binder/utils/transport_stream_receiver.h" |
||||
#include "src/core/ext/transport/binder/wire_format/binder.h" |
||||
#include "src/core/ext/transport/binder/wire_format/wire_reader.h" |
||||
#include "src/core/ext/transport/binder/wire_format/wire_writer.h" |
||||
|
||||
namespace grpc_binder { |
||||
|
||||
class MockWritableParcel : public WritableParcel { |
||||
public: |
||||
MOCK_METHOD(int32_t, GetDataPosition, (), (const, override)); |
||||
MOCK_METHOD(absl::Status, SetDataPosition, (int32_t), (override)); |
||||
MOCK_METHOD(absl::Status, WriteInt32, (int32_t), (override)); |
||||
MOCK_METHOD(absl::Status, WriteBinder, (HasRawBinder*), (override)); |
||||
MOCK_METHOD(absl::Status, WriteString, (absl::string_view), (override)); |
||||
MOCK_METHOD(absl::Status, WriteByteArray, (const int8_t*, int32_t), |
||||
(override)); |
||||
|
||||
MockWritableParcel(); |
||||
}; |
||||
|
||||
class MockReadableParcel : public ReadableParcel { |
||||
public: |
||||
MOCK_METHOD(absl::Status, ReadInt32, (int32_t*), (const, override)); |
||||
MOCK_METHOD(absl::Status, ReadBinder, (std::unique_ptr<Binder>*), |
||||
(const, override)); |
||||
MOCK_METHOD(absl::Status, ReadByteArray, (std::string*), (const, override)); |
||||
MOCK_METHOD(absl::Status, ReadString, (char[111]), (const, override)); |
||||
|
||||
MockReadableParcel(); |
||||
}; |
||||
|
||||
class MockBinder : public Binder { |
||||
public: |
||||
MOCK_METHOD(void, Initialize, (), (override)); |
||||
MOCK_METHOD(absl::Status, PrepareTransaction, (), (override)); |
||||
MOCK_METHOD(absl::Status, Transact, (BinderTransportTxCode), (override)); |
||||
MOCK_METHOD(WritableParcel*, GetWritableParcel, (), (const, override)); |
||||
MOCK_METHOD(ReadableParcel*, GetReadableParcel, (), (const, override)); |
||||
MOCK_METHOD(std::unique_ptr<TransactionReceiver>, ConstructTxReceiver, |
||||
(grpc_core::RefCountedPtr<WireReader>, |
||||
TransactionReceiver::OnTransactCb), |
||||
(const, override)); |
||||
MOCK_METHOD(void*, GetRawBinder, (), (override)); |
||||
|
||||
MockBinder(); |
||||
MockWritableParcel& GetWriter() { return mock_input_; } |
||||
MockReadableParcel& GetReader() { return mock_output_; } |
||||
|
||||
private: |
||||
MockWritableParcel mock_input_; |
||||
MockReadableParcel mock_output_; |
||||
}; |
||||
|
||||
// TODO(waynetu): Implement transaction injection later for more thorough
|
||||
// testing.
|
||||
class MockTransactionReceiver : public TransactionReceiver { |
||||
public: |
||||
explicit MockTransactionReceiver(OnTransactCb transact_cb, |
||||
BinderTransportTxCode code, |
||||
const ReadableParcel* output) { |
||||
transact_cb(static_cast<transaction_code_t>(code), output).IgnoreError(); |
||||
} |
||||
|
||||
MOCK_METHOD(void*, GetRawBinder, (), (override)); |
||||
}; |
||||
|
||||
class MockWireWriter : public WireWriter { |
||||
public: |
||||
MOCK_METHOD(absl::Status, RpcCall, (const Transaction&), (override)); |
||||
}; |
||||
|
||||
class MockTransportStreamReceiver : public TransportStreamReceiver { |
||||
public: |
||||
MOCK_METHOD(void, RegisterRecvInitialMetadata, |
||||
(StreamIdentifier, InitialMetadataCallbackType), (override)); |
||||
MOCK_METHOD(void, RegisterRecvMessage, |
||||
(StreamIdentifier, MessageDataCallbackType), (override)); |
||||
MOCK_METHOD(void, RegisterRecvTrailingMetadata, |
||||
(StreamIdentifier, TrailingMetadataCallbackType), (override)); |
||||
MOCK_METHOD(void, NotifyRecvInitialMetadata, |
||||
(StreamIdentifier, absl::StatusOr<Metadata>), (override)); |
||||
MOCK_METHOD(void, NotifyRecvMessage, |
||||
(StreamIdentifier, absl::StatusOr<std::string>), (override)); |
||||
MOCK_METHOD(void, NotifyRecvTrailingMetadata, |
||||
(StreamIdentifier, absl::StatusOr<Metadata>, int), (override)); |
||||
MOCK_METHOD(void, CancelRecvMessageCallbacksDueToTrailingMetadata, |
||||
(StreamIdentifier), (override)); |
||||
MOCK_METHOD(void, Clear, (StreamIdentifier), (override)); |
||||
MOCK_METHOD(void, CancelStream, (StreamIdentifier, absl::Status), (override)); |
||||
}; |
||||
|
||||
} // namespace grpc_binder
|
||||
|
||||
#endif // GRPC_TEST_CORE_TRANSPORT_BINDER_MOCK_OBJECTS_H
|
||||
@ -0,0 +1,287 @@ |
||||
// Copyright 2021 gRPC authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include <gmock/gmock.h> |
||||
#include <gtest/gtest.h> |
||||
|
||||
#include <cassert> |
||||
#include <string> |
||||
#include <utility> |
||||
#include <vector> |
||||
|
||||
#include "absl/memory/memory.h" |
||||
#include "src/core/ext/transport/binder/utils/transport_stream_receiver_impl.h" |
||||
#include "test/core/util/test_config.h" |
||||
|
||||
namespace grpc_binder { |
||||
namespace { |
||||
|
||||
// TODO(waynetu): These are hacks to make callbacks aware of their stream IDs
|
||||
// and sequence numbers. Remove/Refactor these hacks when possible.
|
||||
template <typename T> |
||||
std::pair<StreamIdentifier, int> Decode(const T& /*data*/) { |
||||
assert(false && "This should not be called"); |
||||
return {}; |
||||
} |
||||
|
||||
template <> |
||||
std::pair<StreamIdentifier, int> Decode<std::string>(const std::string& data) { |
||||
assert(data.size() == sizeof(StreamIdentifier) + sizeof(int)); |
||||
StreamIdentifier id{}; |
||||
int seq_num{}; |
||||
std::memcpy(&id, data.data(), sizeof(StreamIdentifier)); |
||||
std::memcpy(&seq_num, data.data() + sizeof(StreamIdentifier), sizeof(int)); |
||||
return std::make_pair(id, seq_num); |
||||
} |
||||
|
||||
template <> |
||||
std::pair<StreamIdentifier, int> Decode<Metadata>(const Metadata& data) { |
||||
assert(data.size() == 1); |
||||
const std::string& encoding = data[0].first; |
||||
return Decode(encoding); |
||||
} |
||||
|
||||
template <typename T> |
||||
T Encode(StreamIdentifier /*id*/, int /*seq_num*/) { |
||||
assert(false && "This should not be called"); |
||||
return {}; |
||||
} |
||||
|
||||
template <> |
||||
std::string Encode<std::string>(StreamIdentifier id, int seq_num) { |
||||
char result[sizeof(StreamIdentifier) + sizeof(int)]; |
||||
std::memcpy(result, &id, sizeof(StreamIdentifier)); |
||||
std::memcpy(result + sizeof(StreamIdentifier), &seq_num, sizeof(int)); |
||||
return std::string(result, sizeof(StreamIdentifier) + sizeof(int)); |
||||
} |
||||
|
||||
template <> |
||||
Metadata Encode<Metadata>(StreamIdentifier id, int seq_num) { |
||||
return {{Encode<std::string>(id, seq_num), ""}}; |
||||
} |
||||
|
||||
MATCHER_P2(StreamIdAndSeqNumMatch, id, seq_num, "") { |
||||
auto p = Decode(arg.value()); |
||||
return p.first == id && p.second == seq_num; |
||||
} |
||||
|
||||
// MockCallback is used to verify the every callback passed to transaction
|
||||
// receiver will eventually be invoked with the artifact of its corresponding
|
||||
// binder transaction.
|
||||
template <typename FirstArg, typename... TrailingArgs> |
||||
class MockCallback { |
||||
public: |
||||
explicit MockCallback(StreamIdentifier id, int seq_num) |
||||
: id_(id), seq_num_(seq_num) {} |
||||
|
||||
MOCK_METHOD(void, ActualCallback, (FirstArg), ()); |
||||
|
||||
std::function<void(FirstArg, TrailingArgs...)> GetHandle() { |
||||
return [this](FirstArg first_arg, TrailingArgs...) { |
||||
this->ActualCallback(first_arg); |
||||
}; |
||||
} |
||||
|
||||
void ExpectCallbackInvocation() { |
||||
EXPECT_CALL(*this, ActualCallback(StreamIdAndSeqNumMatch(id_, seq_num_))); |
||||
} |
||||
|
||||
private: |
||||
StreamIdentifier id_; |
||||
int seq_num_; |
||||
}; |
||||
|
||||
using MockInitialMetadataCallback = MockCallback<absl::StatusOr<Metadata>>; |
||||
using MockMessageCallback = MockCallback<absl::StatusOr<std::string>>; |
||||
using MockTrailingMetadataCallback = |
||||
MockCallback<absl::StatusOr<Metadata>, int>; |
||||
|
||||
class MockOpBatch { |
||||
public: |
||||
MockOpBatch(StreamIdentifier id, int flag, int seq_num) |
||||
: id_(id), flag_(flag), seq_num_(seq_num) { |
||||
if (flag_ & kFlagPrefix) { |
||||
initial_metadata_callback_ = |
||||
absl::make_unique<MockInitialMetadataCallback>(id_, seq_num_); |
||||
} |
||||
if (flag_ & kFlagMessageData) { |
||||
message_callback_ = absl::make_unique<MockMessageCallback>(id_, seq_num_); |
||||
} |
||||
if (flag_ & kFlagSuffix) { |
||||
trailing_metadata_callback_ = |
||||
absl::make_unique<MockTrailingMetadataCallback>(id_, seq_num_); |
||||
} |
||||
} |
||||
|
||||
void Complete(TransportStreamReceiver& receiver) { |
||||
if (flag_ & kFlagPrefix) { |
||||
initial_metadata_callback_->ExpectCallbackInvocation(); |
||||
receiver.NotifyRecvInitialMetadata(id_, Encode<Metadata>(id_, seq_num_)); |
||||
} |
||||
if (flag_ & kFlagMessageData) { |
||||
message_callback_->ExpectCallbackInvocation(); |
||||
receiver.NotifyRecvMessage(id_, Encode<std::string>(id_, seq_num_)); |
||||
} |
||||
if (flag_ & kFlagSuffix) { |
||||
trailing_metadata_callback_->ExpectCallbackInvocation(); |
||||
receiver.NotifyRecvTrailingMetadata(id_, Encode<Metadata>(id_, seq_num_), |
||||
0); |
||||
} |
||||
} |
||||
|
||||
void RequestRecv(TransportStreamReceiver& receiver) { |
||||
if (flag_ & kFlagPrefix) { |
||||
receiver.RegisterRecvInitialMetadata( |
||||
id_, initial_metadata_callback_->GetHandle()); |
||||
} |
||||
if (flag_ & kFlagMessageData) { |
||||
receiver.RegisterRecvMessage(id_, message_callback_->GetHandle()); |
||||
} |
||||
if (flag_ & kFlagSuffix) { |
||||
receiver.RegisterRecvTrailingMetadata( |
||||
id_, trailing_metadata_callback_->GetHandle()); |
||||
} |
||||
} |
||||
|
||||
MockOpBatch NextBatch(int flag) const { |
||||
return MockOpBatch(id_, flag, seq_num_ + 1); |
||||
} |
||||
|
||||
private: |
||||
std::unique_ptr<MockInitialMetadataCallback> initial_metadata_callback_; |
||||
std::unique_ptr<MockMessageCallback> message_callback_; |
||||
std::unique_ptr<MockTrailingMetadataCallback> trailing_metadata_callback_; |
||||
int id_, flag_, seq_num_; |
||||
}; |
||||
|
||||
class TransportStreamReceiverTest : public ::testing::Test { |
||||
protected: |
||||
MockOpBatch NewGrpcStream(int flag) { |
||||
return MockOpBatch(current_id_++, flag, 0); |
||||
} |
||||
|
||||
StreamIdentifier current_id_ = 0; |
||||
}; |
||||
|
||||
const int kFlagAll = kFlagPrefix | kFlagMessageData | kFlagSuffix; |
||||
|
||||
} // namespace
|
||||
|
||||
TEST_F(TransportStreamReceiverTest, MultipleStreamRequestThenComplete) { |
||||
TransportStreamReceiverImpl receiver(/*is_client=*/true); |
||||
MockOpBatch t0 = NewGrpcStream(kFlagAll); |
||||
t0.RequestRecv(receiver); |
||||
t0.Complete(receiver); |
||||
} |
||||
|
||||
TEST_F(TransportStreamReceiverTest, MultipleStreamCompleteThenRequest) { |
||||
TransportStreamReceiverImpl receiver(/*is_client=*/true); |
||||
MockOpBatch t0 = NewGrpcStream(kFlagAll); |
||||
t0.Complete(receiver); |
||||
t0.RequestRecv(receiver); |
||||
} |
||||
|
||||
TEST_F(TransportStreamReceiverTest, MultipleStreamInterleaved) { |
||||
TransportStreamReceiverImpl receiver(/*is_client=*/true); |
||||
MockOpBatch t0 = NewGrpcStream(kFlagAll); |
||||
MockOpBatch t1 = NewGrpcStream(kFlagAll); |
||||
t1.Complete(receiver); |
||||
t0.Complete(receiver); |
||||
t0.RequestRecv(receiver); |
||||
t1.RequestRecv(receiver); |
||||
} |
||||
|
||||
TEST_F(TransportStreamReceiverTest, MultipleStreamInterleavedReversed) { |
||||
TransportStreamReceiverImpl receiver(/*is_client=*/true); |
||||
MockOpBatch t0 = NewGrpcStream(kFlagAll); |
||||
MockOpBatch t1 = NewGrpcStream(kFlagAll); |
||||
t0.RequestRecv(receiver); |
||||
t1.RequestRecv(receiver); |
||||
t1.Complete(receiver); |
||||
t0.Complete(receiver); |
||||
} |
||||
|
||||
TEST_F(TransportStreamReceiverTest, MultipleStreamMoreInterleaved) { |
||||
TransportStreamReceiverImpl receiver(/*is_client=*/true); |
||||
MockOpBatch t0 = NewGrpcStream(kFlagAll); |
||||
MockOpBatch t1 = NewGrpcStream(kFlagAll); |
||||
t0.RequestRecv(receiver); |
||||
t1.Complete(receiver); |
||||
MockOpBatch t2 = NewGrpcStream(kFlagAll); |
||||
t2.RequestRecv(receiver); |
||||
t0.Complete(receiver); |
||||
t1.RequestRecv(receiver); |
||||
t2.Complete(receiver); |
||||
} |
||||
|
||||
TEST_F(TransportStreamReceiverTest, SingleStreamUnaryCall) { |
||||
TransportStreamReceiverImpl receiver(/*is_client=*/true); |
||||
MockOpBatch t0 = NewGrpcStream(kFlagPrefix); |
||||
MockOpBatch t1 = t0.NextBatch(kFlagMessageData); |
||||
MockOpBatch t2 = t1.NextBatch(kFlagSuffix); |
||||
t0.RequestRecv(receiver); |
||||
t1.RequestRecv(receiver); |
||||
t2.RequestRecv(receiver); |
||||
t0.Complete(receiver); |
||||
t1.Complete(receiver); |
||||
t2.Complete(receiver); |
||||
} |
||||
|
||||
TEST_F(TransportStreamReceiverTest, SingleStreamStreamingCall) { |
||||
TransportStreamReceiverImpl receiver(/*is_client=*/true); |
||||
MockOpBatch t0 = NewGrpcStream(kFlagPrefix); |
||||
t0.RequestRecv(receiver); |
||||
t0.Complete(receiver); |
||||
MockOpBatch t1 = t0.NextBatch(kFlagMessageData); |
||||
t1.Complete(receiver); |
||||
t1.RequestRecv(receiver); |
||||
MockOpBatch t2 = t1.NextBatch(kFlagMessageData); |
||||
t2.RequestRecv(receiver); |
||||
t2.Complete(receiver); |
||||
MockOpBatch t3 = t2.NextBatch(kFlagMessageData); |
||||
MockOpBatch t4 = t3.NextBatch(kFlagMessageData); |
||||
t3.Complete(receiver); |
||||
t4.Complete(receiver); |
||||
t3.RequestRecv(receiver); |
||||
t4.RequestRecv(receiver); |
||||
} |
||||
|
||||
TEST_F(TransportStreamReceiverTest, DISABLED_SingleStreamBufferedCallbacks) { |
||||
TransportStreamReceiverImpl receiver(/*is_client=*/true); |
||||
MockOpBatch t0 = NewGrpcStream(kFlagPrefix); |
||||
MockOpBatch t1 = t0.NextBatch(kFlagMessageData); |
||||
MockOpBatch t2 = t1.NextBatch(kFlagMessageData); |
||||
MockOpBatch t3 = t2.NextBatch(kFlagSuffix); |
||||
t0.RequestRecv(receiver); |
||||
// TODO(waynetu): Can gRPC issues recv_message before it actually receives the
|
||||
// previous one?
|
||||
t1.RequestRecv(receiver); |
||||
t2.RequestRecv(receiver); |
||||
t3.RequestRecv(receiver); |
||||
t0.Complete(receiver); |
||||
t1.Complete(receiver); |
||||
t2.Complete(receiver); |
||||
t3.Complete(receiver); |
||||
} |
||||
|
||||
// TODO(waynetu): Should we have some concurrent stress tests to make sure that
|
||||
// thread safety is well taken care of?
|
||||
|
||||
} // namespace grpc_binder
|
||||
|
||||
int main(int argc, char** argv) { |
||||
::testing::InitGoogleTest(&argc, argv); |
||||
grpc::testing::TestEnvironment env(argc, argv); |
||||
return RUN_ALL_TESTS(); |
||||
} |
||||
@ -0,0 +1,278 @@ |
||||
// Copyright 2021 gRPC authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// Unit tests for WireReaderImpl.
|
||||
//
|
||||
// WireReaderImpl is responsible for turning incoming transactions into
|
||||
// top-level metadata. The following tests verify that the interactions between
|
||||
// WireReaderImpl and both the output (readable) parcel and the transport stream
|
||||
// receiver are correct in all possible situations.
|
||||
#include <gtest/gtest.h> |
||||
|
||||
#include <memory> |
||||
#include <string> |
||||
#include <utility> |
||||
|
||||
#include "absl/memory/memory.h" |
||||
#include "src/core/ext/transport/binder/wire_format/wire_reader_impl.h" |
||||
#include "test/core/transport/binder/mock_objects.h" |
||||
#include "test/core/util/test_config.h" |
||||
|
||||
namespace grpc_binder { |
||||
|
||||
using ::testing::DoAll; |
||||
using ::testing::Return; |
||||
using ::testing::SetArgPointee; |
||||
using ::testing::StrictMock; |
||||
|
||||
namespace { |
||||
|
||||
class WireReaderTest : public ::testing::Test { |
||||
public: |
||||
WireReaderTest() |
||||
: transport_stream_receiver_( |
||||
std::make_shared<StrictMock<MockTransportStreamReceiver>>()), |
||||
wire_reader_(transport_stream_receiver_, /*is_client=*/true) {} |
||||
|
||||
protected: |
||||
void ExpectReadInt32(int result) { |
||||
EXPECT_CALL(mock_readable_parcel_, ReadInt32) |
||||
.WillOnce(DoAll(SetArgPointee<0>(result), Return(absl::OkStatus()))); |
||||
} |
||||
|
||||
void ExpectReadByteArray(const std::string& buffer) { |
||||
ExpectReadInt32(buffer.length()); |
||||
if (!buffer.empty()) { |
||||
EXPECT_CALL(mock_readable_parcel_, ReadByteArray) |
||||
.WillOnce([buffer](std::string* data) { |
||||
*data = buffer; |
||||
return absl::OkStatus(); |
||||
}); |
||||
} |
||||
} |
||||
|
||||
template <typename T> |
||||
absl::Status CallProcessTransaction(T tx_code) { |
||||
return wire_reader_.ProcessTransaction( |
||||
static_cast<transaction_code_t>(tx_code), &mock_readable_parcel_); |
||||
} |
||||
|
||||
std::shared_ptr<StrictMock<MockTransportStreamReceiver>> |
||||
transport_stream_receiver_; |
||||
WireReaderImpl wire_reader_; |
||||
StrictMock<MockReadableParcel> mock_readable_parcel_; |
||||
}; |
||||
|
||||
MATCHER_P(StatusOrStrEq, target, "") { |
||||
if (!arg.ok()) return false; |
||||
return arg.value() == target; |
||||
} |
||||
|
||||
MATCHER_P(StatusOrContainerEq, target, "") { |
||||
if (!arg.ok()) return false; |
||||
return arg.value() == target; |
||||
} |
||||
|
||||
} // namespace
|
||||
|
||||
TEST_F(WireReaderTest, SetupTransport) { |
||||
auto mock_binder = absl::make_unique<MockBinder>(); |
||||
MockBinder& mock_binder_ref = *mock_binder; |
||||
|
||||
::testing::InSequence sequence; |
||||
EXPECT_CALL(mock_binder_ref, Initialize); |
||||
EXPECT_CALL(mock_binder_ref, PrepareTransaction); |
||||
const MockReadableParcel mock_readable_parcel; |
||||
EXPECT_CALL(mock_binder_ref, GetWritableParcel); |
||||
|
||||
// Write version.
|
||||
EXPECT_CALL(mock_binder_ref.GetWriter(), WriteInt32(77)); |
||||
|
||||
// The transaction receiver immediately informs the wire writer that the
|
||||
// transport has been successfully set up.
|
||||
EXPECT_CALL(mock_binder_ref, ConstructTxReceiver); |
||||
|
||||
EXPECT_CALL(mock_binder_ref.GetReader(), ReadInt32); |
||||
EXPECT_CALL(mock_binder_ref.GetReader(), ReadBinder); |
||||
|
||||
// Write transaction receiver.
|
||||
EXPECT_CALL(mock_binder_ref.GetWriter(), WriteBinder); |
||||
// Perform transaction.
|
||||
EXPECT_CALL(mock_binder_ref, Transact); |
||||
|
||||
wire_reader_.SetupTransport(std::move(mock_binder)); |
||||
} |
||||
|
||||
TEST_F(WireReaderTest, ProcessTransactionControlMessageSetupTransport) { |
||||
::testing::InSequence sequence; |
||||
|
||||
EXPECT_CALL(mock_readable_parcel_, ReadInt32); |
||||
EXPECT_CALL(mock_readable_parcel_, ReadBinder) |
||||
.WillOnce([&](std::unique_ptr<Binder>* binder) { |
||||
auto mock_binder = absl::make_unique<MockBinder>(); |
||||
// binder that is read from the output parcel must first be initialized
|
||||
// before it can be used.
|
||||
EXPECT_CALL(*mock_binder, Initialize); |
||||
*binder = std::move(mock_binder); |
||||
return absl::OkStatus(); |
||||
}); |
||||
|
||||
EXPECT_TRUE( |
||||
CallProcessTransaction(BinderTransportTxCode::SETUP_TRANSPORT).ok()); |
||||
} |
||||
|
||||
TEST_F(WireReaderTest, ProcessTransactionControlMessagePingResponse) { |
||||
EXPECT_CALL(mock_readable_parcel_, ReadInt32); |
||||
EXPECT_TRUE( |
||||
CallProcessTransaction(BinderTransportTxCode::PING_RESPONSE).ok()); |
||||
} |
||||
|
||||
TEST_F(WireReaderTest, ProcessTransactionServerRpcDataEmptyFlagIgnored) { |
||||
::testing::InSequence sequence; |
||||
|
||||
// first transaction: empty flag
|
||||
ExpectReadInt32(0); |
||||
// Won't further read sequence number.
|
||||
EXPECT_TRUE(CallProcessTransaction(kFirstCallId).ok()); |
||||
} |
||||
|
||||
TEST_F(WireReaderTest, |
||||
ProcessTransactionServerRpcDataFlagPrefixWithoutMetadata) { |
||||
::testing::InSequence sequence; |
||||
|
||||
// flag
|
||||
ExpectReadInt32(kFlagPrefix); |
||||
// sequence number
|
||||
ExpectReadInt32(0); |
||||
|
||||
// count
|
||||
ExpectReadInt32(0); |
||||
EXPECT_CALL( |
||||
*transport_stream_receiver_, |
||||
NotifyRecvInitialMetadata(kFirstCallId, StatusOrContainerEq(Metadata{}))); |
||||
|
||||
EXPECT_TRUE(CallProcessTransaction(kFirstCallId).ok()); |
||||
} |
||||
|
||||
TEST_F(WireReaderTest, ProcessTransactionServerRpcDataFlagPrefixWithMetadata) { |
||||
::testing::InSequence sequence; |
||||
|
||||
// flag
|
||||
ExpectReadInt32(kFlagPrefix); |
||||
// sequence number
|
||||
ExpectReadInt32(0); |
||||
|
||||
const std::vector<std::pair<std::string, std::string>> kMetadata = { |
||||
{"", ""}, |
||||
{"", "value"}, |
||||
{"key", ""}, |
||||
{"key", "value"}, |
||||
{"another-key", "another-value"}, |
||||
}; |
||||
|
||||
// count
|
||||
ExpectReadInt32(kMetadata.size()); |
||||
for (const auto& md : kMetadata) { |
||||
// metadata key
|
||||
ExpectReadByteArray(md.first); |
||||
// metadata val
|
||||
// TODO(waynetu): metadata value can also be "parcelable".
|
||||
ExpectReadByteArray(md.second); |
||||
} |
||||
EXPECT_CALL( |
||||
*transport_stream_receiver_, |
||||
NotifyRecvInitialMetadata(kFirstCallId, StatusOrContainerEq(kMetadata))); |
||||
|
||||
EXPECT_TRUE(CallProcessTransaction(kFirstCallId).ok()); |
||||
} |
||||
|
||||
TEST_F(WireReaderTest, ProcessTransactionServerRpcDataFlagMessageDataNonEmpty) { |
||||
::testing::InSequence sequence; |
||||
|
||||
// flag
|
||||
ExpectReadInt32(kFlagMessageData); |
||||
// sequence number
|
||||
ExpectReadInt32(0); |
||||
|
||||
// message data
|
||||
// TODO(waynetu): message data can also be "parcelable".
|
||||
const std::string kMessageData = "message data"; |
||||
ExpectReadByteArray(kMessageData); |
||||
EXPECT_CALL(*transport_stream_receiver_, |
||||
NotifyRecvMessage(kFirstCallId, StatusOrStrEq(kMessageData))); |
||||
|
||||
EXPECT_TRUE(CallProcessTransaction(kFirstCallId).ok()); |
||||
} |
||||
|
||||
TEST_F(WireReaderTest, ProcessTransactionServerRpcDataFlagMessageDataEmpty) { |
||||
::testing::InSequence sequence; |
||||
|
||||
// flag
|
||||
ExpectReadInt32(kFlagMessageData); |
||||
// sequence number
|
||||
ExpectReadInt32(0); |
||||
|
||||
// message data
|
||||
// TODO(waynetu): message data can also be "parcelable".
|
||||
const std::string kMessageData = ""; |
||||
ExpectReadByteArray(kMessageData); |
||||
EXPECT_CALL(*transport_stream_receiver_, |
||||
NotifyRecvMessage(kFirstCallId, StatusOrStrEq(kMessageData))); |
||||
|
||||
EXPECT_TRUE(CallProcessTransaction(kFirstCallId).ok()); |
||||
} |
||||
|
||||
TEST_F(WireReaderTest, ProcessTransactionServerRpcDataFlagSuffixWithStatus) { |
||||
::testing::InSequence sequence; |
||||
|
||||
constexpr int kStatus = 0x1234; |
||||
// flag
|
||||
ExpectReadInt32(kFlagSuffix | kFlagStatusDescription | (kStatus << 16)); |
||||
// sequence number
|
||||
ExpectReadInt32(0); |
||||
// status description
|
||||
EXPECT_CALL(mock_readable_parcel_, ReadString); |
||||
// metadata count
|
||||
ExpectReadInt32(0); |
||||
EXPECT_CALL(*transport_stream_receiver_, |
||||
NotifyRecvTrailingMetadata( |
||||
kFirstCallId, StatusOrContainerEq(Metadata{}), kStatus)); |
||||
|
||||
EXPECT_TRUE(CallProcessTransaction(kFirstCallId).ok()); |
||||
} |
||||
|
||||
TEST_F(WireReaderTest, ProcessTransactionServerRpcDataFlagSuffixWithoutStatus) { |
||||
::testing::InSequence sequence; |
||||
|
||||
// flag
|
||||
ExpectReadInt32(kFlagSuffix); |
||||
// sequence number
|
||||
ExpectReadInt32(0); |
||||
// No status description
|
||||
// metadata count
|
||||
ExpectReadInt32(0); |
||||
EXPECT_CALL(*transport_stream_receiver_, |
||||
NotifyRecvTrailingMetadata(kFirstCallId, |
||||
StatusOrContainerEq(Metadata{}), 0)); |
||||
|
||||
EXPECT_TRUE(CallProcessTransaction(kFirstCallId).ok()); |
||||
} |
||||
|
||||
} // namespace grpc_binder
|
||||
|
||||
int main(int argc, char** argv) { |
||||
::testing::InitGoogleTest(&argc, argv); |
||||
grpc::testing::TestEnvironment env(argc, argv); |
||||
return RUN_ALL_TESTS(); |
||||
} |
||||
@ -0,0 +1,181 @@ |
||||
// Copyright 2021 gRPC authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "src/core/ext/transport/binder/wire_format/wire_writer.h" |
||||
|
||||
#include <gtest/gtest.h> |
||||
#include <string> |
||||
#include <utility> |
||||
|
||||
#include "absl/memory/memory.h" |
||||
#include "test/core/transport/binder/mock_objects.h" |
||||
#include "test/core/util/test_config.h" |
||||
|
||||
namespace grpc_binder { |
||||
|
||||
using ::testing::Return; |
||||
using ::testing::StrictMock; |
||||
|
||||
MATCHER_P(StrEqInt8Ptr, target, "") { |
||||
return std::string(reinterpret_cast<const char*>(arg)) == target; |
||||
} |
||||
|
||||
TEST(WireWriterTest, RpcCall) { |
||||
auto mock_binder = absl::make_unique<MockBinder>(); |
||||
MockBinder& mock_binder_ref = *mock_binder; |
||||
StrictMock<MockWritableParcel> mock_writable_parcel; |
||||
ON_CALL(mock_binder_ref, GetWritableParcel) |
||||
.WillByDefault(Return(&mock_writable_parcel)); |
||||
WireWriterImpl wire_writer(std::move(mock_binder)); |
||||
|
||||
auto ExpectWriteByteArray = [&](const std::string& target) { |
||||
// length
|
||||
EXPECT_CALL(mock_writable_parcel, WriteInt32(target.size())); |
||||
if (!target.empty()) { |
||||
// content
|
||||
EXPECT_CALL(mock_writable_parcel, |
||||
WriteByteArray(StrEqInt8Ptr(target), target.size())); |
||||
} |
||||
}; |
||||
|
||||
::testing::InSequence sequence; |
||||
int sequence_number = 0; |
||||
int tx_code = kFirstCallId; |
||||
|
||||
{ |
||||
// flag
|
||||
EXPECT_CALL(mock_writable_parcel, WriteInt32(0)); |
||||
// sequence number
|
||||
EXPECT_CALL(mock_writable_parcel, WriteInt32(sequence_number)); |
||||
|
||||
EXPECT_CALL(mock_binder_ref, Transact(BinderTransportTxCode(tx_code))); |
||||
|
||||
Transaction tx(tx_code, sequence_number, /*is_client=*/true); |
||||
EXPECT_TRUE(wire_writer.RpcCall(tx).ok()); |
||||
sequence_number++; |
||||
tx_code++; |
||||
} |
||||
{ |
||||
// flag
|
||||
EXPECT_CALL(mock_writable_parcel, WriteInt32(kFlagPrefix)); |
||||
// sequence number
|
||||
EXPECT_CALL(mock_writable_parcel, WriteInt32(sequence_number)); |
||||
|
||||
EXPECT_CALL(mock_writable_parcel, |
||||
WriteString(absl::string_view("/example/method/ref"))); |
||||
|
||||
const std::vector<std::pair<std::string, std::string>> kMetadata = { |
||||
{"", ""}, |
||||
{"", "value"}, |
||||
{"key", ""}, |
||||
{"key", "value"}, |
||||
{"another-key", "another-value"}, |
||||
}; |
||||
|
||||
// Number of metadata
|
||||
EXPECT_CALL(mock_writable_parcel, WriteInt32(kMetadata.size())); |
||||
|
||||
for (const auto& md : kMetadata) { |
||||
ExpectWriteByteArray(md.first); |
||||
ExpectWriteByteArray(md.second); |
||||
} |
||||
|
||||
EXPECT_CALL(mock_binder_ref, |
||||
Transact(BinderTransportTxCode(kFirstCallId + 1))); |
||||
|
||||
Transaction tx(kFirstCallId + 1, 1, /*is_client=*/true); |
||||
tx.SetPrefix(kMetadata); |
||||
tx.SetMethodRef("/example/method/ref"); |
||||
EXPECT_TRUE(wire_writer.RpcCall(tx).ok()); |
||||
sequence_number++; |
||||
tx_code++; |
||||
} |
||||
{ |
||||
// flag
|
||||
EXPECT_CALL(mock_writable_parcel, WriteInt32(kFlagMessageData)); |
||||
// sequence number
|
||||
EXPECT_CALL(mock_writable_parcel, WriteInt32(sequence_number)); |
||||
|
||||
ExpectWriteByteArray("data"); |
||||
EXPECT_CALL(mock_binder_ref, Transact(BinderTransportTxCode(tx_code))); |
||||
|
||||
Transaction tx(tx_code, sequence_number, /*is_client=*/true); |
||||
tx.SetData("data"); |
||||
EXPECT_TRUE(wire_writer.RpcCall(tx).ok()); |
||||
} |
||||
{ |
||||
// flag
|
||||
EXPECT_CALL(mock_writable_parcel, WriteInt32(kFlagSuffix)); |
||||
// sequence number
|
||||
EXPECT_CALL(mock_writable_parcel, WriteInt32(sequence_number)); |
||||
|
||||
EXPECT_CALL(mock_binder_ref, Transact(BinderTransportTxCode(tx_code))); |
||||
|
||||
Transaction tx(tx_code, sequence_number, /*is_client=*/true); |
||||
tx.SetSuffix({}); |
||||
EXPECT_TRUE(wire_writer.RpcCall(tx).ok()); |
||||
sequence_number++; |
||||
tx_code++; |
||||
} |
||||
{ |
||||
// flag
|
||||
EXPECT_CALL(mock_writable_parcel, |
||||
WriteInt32(kFlagPrefix | kFlagMessageData | kFlagSuffix)); |
||||
// sequence number
|
||||
EXPECT_CALL(mock_writable_parcel, WriteInt32(sequence_number)); |
||||
|
||||
EXPECT_CALL(mock_writable_parcel, |
||||
WriteString(absl::string_view("/example/method/ref"))); |
||||
|
||||
const std::vector<std::pair<std::string, std::string>> kMetadata = { |
||||
{"", ""}, |
||||
{"", "value"}, |
||||
{"key", ""}, |
||||
{"key", "value"}, |
||||
{"another-key", "another-value"}, |
||||
}; |
||||
|
||||
// Number of metadata
|
||||
EXPECT_CALL(mock_writable_parcel, WriteInt32(kMetadata.size())); |
||||
|
||||
for (const auto& md : kMetadata) { |
||||
ExpectWriteByteArray(md.first); |
||||
ExpectWriteByteArray(md.second); |
||||
} |
||||
|
||||
// Empty message data
|
||||
ExpectWriteByteArray(""); |
||||
|
||||
EXPECT_CALL(mock_binder_ref, Transact(BinderTransportTxCode(tx_code))); |
||||
|
||||
Transaction tx(tx_code, sequence_number, /*is_client=*/true); |
||||
// TODO(waynetu): Implement a helper function that automatically creates
|
||||
// EXPECT_CALL based on the tx object.
|
||||
tx.SetPrefix(kMetadata); |
||||
tx.SetMethodRef("/example/method/ref"); |
||||
tx.SetData(""); |
||||
tx.SetSuffix({}); |
||||
EXPECT_TRUE(wire_writer.RpcCall(tx).ok()); |
||||
sequence_number++; |
||||
tx_code++; |
||||
} |
||||
} |
||||
|
||||
} // namespace grpc_binder
|
||||
|
||||
int main(int argc, char** argv) { |
||||
::testing::InitGoogleTest(&argc, argv); |
||||
grpc::testing::TestEnvironment env(argc, argv); |
||||
return RUN_ALL_TESTS(); |
||||
} |
||||
Loading…
Reference in new issue