From 50a7a68ca2a5ade22a97502389ec1e0d4dcb0a10 Mon Sep 17 00:00:00 2001 From: Craig Tiller Date: Thu, 4 Jun 2015 12:53:40 -0700 Subject: Progress commit on fixing up C++ --- src/cpp/server/server.cc | 59 +++++++++------------------------------- src/cpp/server/server_context.cc | 21 ++++++++------ 2 files changed, 26 insertions(+), 54 deletions(-) (limited to 'src/cpp/server') diff --git a/src/cpp/server/server.cc b/src/cpp/server/server.cc index dbd88c5b8c..c08506c97f 100644 --- a/src/cpp/server/server.cc +++ b/src/cpp/server/server.cc @@ -48,7 +48,6 @@ #include #include "src/core/profiling/timers.h" -#include "src/cpp/proto/proto_utils.h" namespace grpc { @@ -68,10 +67,7 @@ class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag { in_flight_(false), has_request_payload_(method->method_type() == RpcMethod::NORMAL_RPC || method->method_type() == - RpcMethod::SERVER_STREAMING), - has_response_payload_(method->method_type() == RpcMethod::NORMAL_RPC || - method->method_type() == - RpcMethod::CLIENT_STREAMING) { + RpcMethod::SERVER_STREAMING) { grpc_metadata_array_init(&request_metadata_); } @@ -116,7 +112,6 @@ class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag { ctx_(mrd->deadline_, mrd->request_metadata_.metadata, mrd->request_metadata_.count), has_request_payload_(mrd->has_request_payload_), - has_response_payload_(mrd->has_response_payload_), request_payload_(mrd->request_payload_), method_(mrd->method_) { ctx_.call_ = mrd->call_; @@ -133,35 +128,9 @@ class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag { } void Run() { - std::unique_ptr req; - std::unique_ptr res; - if (has_request_payload_) { - GRPC_TIMER_BEGIN(GRPC_PTAG_PROTO_DESERIALIZE, call_.call()); - req.reset(method_->AllocateRequestProto()); - if (!DeserializeProto(request_payload_, req.get(), - call_.max_message_size())) { - // FIXME(yangg) deal with deserialization failure - cq_.Shutdown(); - return; - } - GRPC_TIMER_END(GRPC_PTAG_PROTO_DESERIALIZE, call_.call()); - } - if (has_response_payload_) { - res.reset(method_->AllocateResponseProto()); - } ctx_.BeginCompletionOp(&call_); - auto status = method_->handler()->RunHandler( - MethodHandler::HandlerParameter(&call_, &ctx_, req.get(), res.get())); - CallOpBuffer buf; - if (!ctx_.sent_initial_metadata_) { - buf.AddSendInitialMetadata(&ctx_.initial_metadata_); - } - if (has_response_payload_) { - buf.AddSendMessage(*res); - } - buf.AddServerSendStatus(&ctx_.trailing_metadata_, status); - call_.PerformOps(&buf); - cq_.Pluck(&buf); /* status ignored */ + method_->handler()->RunHandler( + MethodHandler::HandlerParameter(&call_, &ctx_, request_payload_, call_.max_message_size())); void* ignored_tag; bool ignored_ok; cq_.Shutdown(); @@ -173,7 +142,6 @@ class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag { Call call_; ServerContext ctx_; const bool has_request_payload_; - const bool has_response_payload_; grpc_byte_buffer* request_payload_; RpcServiceMethod* const method_; }; @@ -183,7 +151,6 @@ class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag { void* const tag_; bool in_flight_; const bool has_request_payload_; - const bool has_response_payload_; grpc_call* call_; gpr_timespec deadline_; grpc_metadata_array request_metadata_; @@ -251,9 +218,9 @@ bool Server::RegisterService(RpcService* service) { } bool Server::RegisterAsyncService(AsynchronousService* service) { - GPR_ASSERT(service->dispatch_impl_ == nullptr && + GPR_ASSERT(service->server_ == nullptr && "Can only register an asynchronous service against one server."); - service->dispatch_impl_ = this; + service->server_ = this; service->request_args_ = new void*[service->method_count_]; for (size_t i = 0; i < service->method_count_; ++i) { void* tag = grpc_server_register_method(server_, service->method_names_[i], @@ -318,15 +285,16 @@ void Server::Wait() { } } -void Server::PerformOpsOnCall(CallOpBuffer* buf, Call* call) { +void Server::PerformOpsOnCall(CallOpSetInterface* ops, Call* call) { static const size_t MAX_OPS = 8; - size_t nops = MAX_OPS; - grpc_op ops[MAX_OPS]; - buf->FillOps(ops, &nops); + size_t nops = 0; + grpc_op cops[MAX_OPS]; + ops->FillOps(cops, &nops); GPR_ASSERT(GRPC_CALL_OK == - grpc_call_start_batch(call->call(), ops, nops, buf)); + grpc_call_start_batch(call->call(), cops, nops, ops)); } +#if 0 class Server::AsyncRequest GRPC_FINAL : public CompletionQueueTag { public: AsyncRequest(Server* server, void* registered_method, ServerContext* ctx, @@ -352,9 +320,7 @@ class Server::AsyncRequest GRPC_FINAL : public CompletionQueueTag { notification_cq->cq(), this); } - AsyncRequest(Server* server, GenericServerContext* ctx, - ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, - ServerCompletionQueue* notification_cq, void* tag) + AsyncRequest() : tag_(tag), request_(nullptr), stream_(stream), @@ -454,6 +420,7 @@ void Server::RequestAsyncGenericCall(GenericServerContext* context, void* tag) { new AsyncRequest(this, context, stream, call_cq, notification_cq, tag); } +#endif void Server::ScheduleCallback() { { diff --git a/src/cpp/server/server_context.cc b/src/cpp/server/server_context.cc index 6b5e41d0a8..eea9645e37 100644 --- a/src/cpp/server/server_context.cc +++ b/src/cpp/server/server_context.cc @@ -43,12 +43,12 @@ namespace grpc { // CompletionOp -class ServerContext::CompletionOp GRPC_FINAL : public CallOpBuffer { +class ServerContext::CompletionOp GRPC_FINAL : public CallOpSetInterface { public: // initial refs: one in the server context, one in the cq - CompletionOp() : refs_(2), finalized_(false), cancelled_(false) { - AddServerRecvClose(&cancelled_); - } + CompletionOp() : refs_(2), finalized_(false), cancelled_(0) {} + + void FillOps(grpc_op* ops, size_t* nops) GRPC_OVERRIDE; bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE; bool CheckCancelled(CompletionQueue* cq); @@ -59,7 +59,7 @@ class ServerContext::CompletionOp GRPC_FINAL : public CallOpBuffer { grpc::mutex mu_; int refs_; bool finalized_; - bool cancelled_; + int cancelled_; }; void ServerContext::CompletionOp::Unref() { @@ -73,14 +73,19 @@ void ServerContext::CompletionOp::Unref() { bool ServerContext::CompletionOp::CheckCancelled(CompletionQueue* cq) { cq->TryPluck(this); grpc::lock_guard g(mu_); - return finalized_ ? cancelled_ : false; + return finalized_ ? cancelled_ != 0 : false; +} + +void ServerContext::CompletionOp::FillOps(grpc_op* ops, size_t* nops) { + ops->op = GRPC_OP_RECV_CLOSE_ON_SERVER; + ops->data.recv_close_on_server.cancelled = &cancelled_; + *nops = 1; } bool ServerContext::CompletionOp::FinalizeResult(void** tag, bool* status) { - GPR_ASSERT(CallOpBuffer::FinalizeResult(tag, status)); grpc::unique_lock lock(mu_); finalized_ = true; - if (!*status) cancelled_ = true; + if (!*status) cancelled_ = 1; if (--refs_ == 0) { lock.unlock(); delete this; -- cgit v1.2.3 From 7bc97bc6def1a9d8237e42fe067fbfe64fc2ee43 Mon Sep 17 00:00:00 2001 From: Craig Tiller Date: Thu, 4 Jun 2015 17:22:54 -0700 Subject: Everything compiles again --- include/grpc++/server.h | 88 +++++++++++++++++++++++++++++++++++++----------- src/cpp/server/server.cc | 63 ++++++++++++++++++++++++++++++++++ 2 files changed, 131 insertions(+), 20 deletions(-) (limited to 'src/cpp/server') diff --git a/include/grpc++/server.h b/include/grpc++/server.h index 4784bace1c..a6883e24e6 100644 --- a/include/grpc++/server.h +++ b/include/grpc++/server.h @@ -101,40 +101,82 @@ class Server GRPC_FINAL : public GrpcLibrary, class BaseAsyncRequest : public CompletionQueueTag { public: - BaseAsyncRequest(Server* server, - ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, - ServerCompletionQueue* notification_cq, void* tag); - - private: + BaseAsyncRequest(Server* server, ServerContext* context, + ServerAsyncStreamingInterface* stream, + CompletionQueue* call_cq, + void* tag); + virtual ~BaseAsyncRequest(); + + bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE; + + protected: + void FinalizeMetadata(ServerContext* context); + + Server* const server_; + ServerContext* const context_; + ServerAsyncStreamingInterface* const stream_; + CompletionQueue* const call_cq_; + grpc_call* call_; + grpc_metadata_array initial_metadata_array_; }; class RegisteredAsyncRequest : public BaseAsyncRequest { public: RegisteredAsyncRequest(Server* server, ServerContext* context, - ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, - ServerCompletionQueue* notification_cq, void* tag) - : BaseAsyncRequest(server, stream, call_cq, notification_cq, tag) {} + ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, void* tag); + + // uses BaseAsyncRequest::FinalizeResult + + protected: + void IssueRequest(void* registered_method, grpc_byte_buffer** payload, ServerCompletionQueue *notification_cq); }; - class NoPayloadAsyncRequest : public RegisteredAsyncRequest { + class NoPayloadAsyncRequest GRPC_FINAL : public RegisteredAsyncRequest { public: - NoPayloadAsyncRequest(Server* server, ServerContext* context, + NoPayloadAsyncRequest(void* registered_method, Server* server, ServerContext* context, ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, ServerCompletionQueue* notification_cq, void* tag) - : RegisteredAsyncRequest(server, context, stream, call_cq, notification_cq, tag) { + : RegisteredAsyncRequest(server, context, stream, call_cq, tag) { + IssueRequest(registered_method, nullptr, notification_cq); } + + // uses RegisteredAsyncRequest::FinalizeResult }; template - class PayloadAsyncRequest : public RegisteredAsyncRequest { - PayloadAsyncRequest(Server* server, ServerContext* context, + class PayloadAsyncRequest GRPC_FINAL : public RegisteredAsyncRequest { + public: + PayloadAsyncRequest(void* registered_method, Server* server, ServerContext* context, ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, - ServerCompletionQueue* notification_cq, void* tag) - : RegisteredAsyncRequest(server, context, stream, call_cq, notification_cq, tag) { + ServerCompletionQueue* notification_cq, void* tag, Message* request) + : RegisteredAsyncRequest(server, context, stream, call_cq, tag), request_(request) { + IssueRequest(registered_method, &payload_, notification_cq); + } + + bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { + bool serialization_status = *status && payload_ && SerializationTraits::Deserialize(payload_, request_, server_->max_message_size_).IsOk(); + bool ret = RegisteredAsyncRequest::FinalizeResult(tag, status); + *status = serialization_status && *status; + return ret; } + + private: + grpc_byte_buffer* payload_; + Message* const request_; }; - class GenericAsyncRequest : public BaseAsyncRequest { + class GenericAsyncRequest GRPC_FINAL : public BaseAsyncRequest { + public: + GenericAsyncRequest(Server* server, GenericServerContext* context, + ServerAsyncStreamingInterface* stream, + CompletionQueue* call_cq, + ServerCompletionQueue* notification_cq, + void* tag); + + bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE; + + private: + grpc_call_details call_details_; }; template @@ -142,19 +184,25 @@ class Server GRPC_FINAL : public GrpcLibrary, ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, ServerCompletionQueue* notification_cq, - void* tag, Message *message); + void* tag, Message *message) { + new PayloadAsyncRequest(registered_method, this, context, stream, call_cq, notification_cq, tag, message); + } void RequestAsyncCall(void* registered_method, ServerContext* context, ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, ServerCompletionQueue* notification_cq, - void* tag); + void* tag) { + new NoPayloadAsyncRequest(registered_method, this, context, stream, call_cq, notification_cq, tag); + } void RequestAsyncGenericCall(GenericServerContext* context, ServerAsyncStreamingInterface* stream, - CompletionQueue* cq, + CompletionQueue* call_cq, ServerCompletionQueue* notification_cq, - void* tag); + void* tag) { + new GenericAsyncRequest(this, context, stream, call_cq, notification_cq, tag); + } const int max_message_size_; diff --git a/src/cpp/server/server.cc b/src/cpp/server/server.cc index c08506c97f..bd97d707a7 100644 --- a/src/cpp/server/server.cc +++ b/src/cpp/server/server.cc @@ -422,6 +422,69 @@ void Server::RequestAsyncGenericCall(GenericServerContext* context, } #endif +Server::BaseAsyncRequest::BaseAsyncRequest(Server* server, ServerContext* context, + ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, void* tag) +: server_(server), context_(context), stream_(stream), call_cq_(call_cq), call_(nullptr) { + memset(&initial_metadata_array_, 0, sizeof(initial_metadata_array_)); +} + +Server::BaseAsyncRequest::~BaseAsyncRequest() { +} + +bool Server::BaseAsyncRequest::FinalizeResult(void** tag, bool* status) { + if (*status) { + for (size_t i = 0; i < initial_metadata_array_.count; i++) { + context_->client_metadata_.insert(std::make_pair( + grpc::string(initial_metadata_array_.metadata[i].key), + grpc::string( + initial_metadata_array_.metadata[i].value, + initial_metadata_array_.metadata[i].value + initial_metadata_array_.metadata[i].value_length))); + } + } + context_->call_ = call_; + context_->cq_ = call_cq_; + Call call(call_, server_, call_cq_, server_->max_message_size_); + if (*status && call_) { + context_->BeginCompletionOp(&call); + } + // just the pointers inside call are copied here + stream_->BindCall(&call); + delete this; + return true; +} + +Server::RegisteredAsyncRequest::RegisteredAsyncRequest(Server* server, ServerContext* context, + ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, void* tag) + : BaseAsyncRequest(server, context, stream, call_cq, tag) {} + + +void Server::RegisteredAsyncRequest::IssueRequest(void* registered_method, grpc_byte_buffer** payload, ServerCompletionQueue *notification_cq) { + grpc_server_request_registered_call( + server_->server_, registered_method, &call_, &context_->deadline_, &initial_metadata_array_, payload, call_cq_->cq(), notification_cq->cq(), this); +} + +Server::GenericAsyncRequest::GenericAsyncRequest(Server* server, GenericServerContext* context, + ServerAsyncStreamingInterface* stream, + CompletionQueue* call_cq, + ServerCompletionQueue* notification_cq, + void* tag) +: BaseAsyncRequest(server, context, stream, call_cq, tag) { + grpc_call_details_init(&call_details_); + GPR_ASSERT(notification_cq); + GPR_ASSERT(call_cq); + grpc_server_request_call(server->server_, &call_, &call_details_, &initial_metadata_array_, + call_cq->cq(), notification_cq->cq(), this); +} + +bool Server::GenericAsyncRequest::FinalizeResult(void** tag, bool* status) { + // TODO(yangg) remove the copy here. + static_cast(context_)->method_ = call_details_.method; + static_cast(context_)->host_ = call_details_.host; + gpr_free(call_details_.method); + gpr_free(call_details_.host); + return BaseAsyncRequest::FinalizeResult(tag, status); +} + void Server::ScheduleCallback() { { grpc::unique_lock lock(mu_); -- cgit v1.2.3 From ce40de58da69dc5fb1569d4dca934ef7eea4d3b1 Mon Sep 17 00:00:00 2001 From: Craig Tiller Date: Fri, 5 Jun 2015 07:14:58 -0700 Subject: clang-format --- include/grpc++/async_unary_call.h | 13 ++- include/grpc++/byte_buffer.h | 3 +- include/grpc++/completion_queue.h | 2 +- include/grpc++/config.h | 20 ++-- include/grpc++/config_protobuf.h | 3 +- include/grpc++/impl/call.h | 68 ++++++----- include/grpc++/impl/client_unary_call.h | 13 +-- include/grpc++/impl/proto_utils.h | 18 +-- include/grpc++/impl/rpc_service_method.h | 24 ++-- include/grpc++/impl/serialization_traits.h | 5 +- include/grpc++/impl/service_type.h | 19 ++- include/grpc++/server.h | 67 ++++++----- include/grpc++/stream.h | 25 ++-- include/grpc/support/port_platform.h | 20 +++- src/compiler/config.h | 6 +- src/compiler/cpp_generator.cc | 181 ++++++++++++++--------------- src/cpp/client/channel.h | 8 +- src/cpp/proto/proto_utils.cc | 8 +- src/cpp/server/server.cc | 58 ++++----- 19 files changed, 303 insertions(+), 258 deletions(-) (limited to 'src/cpp/server') diff --git a/include/grpc++/async_unary_call.h b/include/grpc++/async_unary_call.h index 3d475d0668..a3c9e20213 100644 --- a/include/grpc++/async_unary_call.h +++ b/include/grpc++/async_unary_call.h @@ -90,9 +90,11 @@ class ClientAsyncResponseReader GRPC_FINAL private: ClientContext* context_; Call call_; - SneakyCallOpSet init_buf_; + SneakyCallOpSet init_buf_; CallOpSet meta_buf_; - CallOpSet, CallOpClientRecvStatus> finish_buf_; + CallOpSet, + CallOpClientRecvStatus> finish_buf_; }; template @@ -119,7 +121,9 @@ class ServerAsyncResponseWriter GRPC_FINAL } // The response is dropped if the status is not OK. if (status.IsOk() && !finish_buf_.SendMessage(msg)) { - finish_buf_.ServerSendStatus(ctx_->trailing_metadata_, Status(INVALID_ARGUMENT, "Failed to serialize message")); + finish_buf_.ServerSendStatus( + ctx_->trailing_metadata_, + Status(INVALID_ARGUMENT, "Failed to serialize message")); } else { finish_buf_.ServerSendStatus(ctx_->trailing_metadata_, status); } @@ -143,7 +147,8 @@ class ServerAsyncResponseWriter GRPC_FINAL Call call_; ServerContext* ctx_; CallOpSet meta_buf_; - CallOpSet finish_buf_; + CallOpSet finish_buf_; }; } // namespace grpc diff --git a/include/grpc++/byte_buffer.h b/include/grpc++/byte_buffer.h index 618ec764df..80b3397a2d 100644 --- a/include/grpc++/byte_buffer.h +++ b/include/grpc++/byte_buffer.h @@ -85,7 +85,8 @@ class ByteBuffer GRPC_FINAL { template <> class SerializationTraits { public: - static Status Deserialize(grpc_byte_buffer* byte_buffer, ByteBuffer* dest, int max_message_size) { + static Status Deserialize(grpc_byte_buffer* byte_buffer, ByteBuffer* dest, + int max_message_size) { dest->set_buffer(byte_buffer); return Status::OK; } diff --git a/include/grpc++/completion_queue.h b/include/grpc++/completion_queue.h index 0490073937..a3e7a9c9f4 100644 --- a/include/grpc++/completion_queue.h +++ b/include/grpc++/completion_queue.h @@ -95,7 +95,7 @@ class CompletionQueue : public GrpcLibrary { // Nonblocking (until deadline) read from queue. // Cannot rely on result of tag or ok if return is TIMEOUT - template + template NextStatus AsyncNext(void** tag, bool* ok, const T& deadline) { TimePoint deadline_tp(deadline); return AsyncNextInternal(tag, ok, deadline_tp.raw_time()); diff --git a/include/grpc++/config.h b/include/grpc++/config.h index af248b66e3..1362c0a1fa 100644 --- a/include/grpc++/config.h +++ b/include/grpc++/config.h @@ -46,7 +46,7 @@ #define GRPC_CXX0X_NO_OVERRIDE 1 #define GRPC_CXX0X_NO_CHRONO 1 #define GRPC_CXX0X_NO_THREAD 1 -#endif +#endif #endif // Visual Studio #ifndef __clang__ @@ -80,16 +80,22 @@ #ifdef GRPC_CXX0X_NO_NULLPTR #include const class { -public: - template operator T*() const {return static_cast(0);} - template operator std::unique_ptr() const { + public: + template + operator T *() const { + return static_cast(0); + } + template + operator std::unique_ptr() const { return std::unique_ptr(static_cast(0)); } - template operator std::shared_ptr() const { + template + operator std::shared_ptr() const { return std::shared_ptr(static_cast(0)); } - operator bool() const {return false;} -private: + operator bool() const { return false; } + + private: void operator&() const = delete; } nullptr = {}; #endif diff --git a/include/grpc++/config_protobuf.h b/include/grpc++/config_protobuf.h index f6938b02ce..3afc7a58e2 100644 --- a/include/grpc++/config_protobuf.h +++ b/include/grpc++/config_protobuf.h @@ -51,8 +51,7 @@ ::google::protobuf::io::ZeroCopyOutputStream #define GRPC_CUSTOM_ZEROCOPYINPUTSTREAM \ ::google::protobuf::io::ZeroCopyInputStream -#define GRPC_CUSTOM_CODEDINPUTSTREAM \ - ::google::protobuf::io::CodedInputStream +#define GRPC_CUSTOM_CODEDINPUTSTREAM ::google::protobuf::io::CodedInputStream #endif namespace grpc { diff --git a/include/grpc++/impl/call.h b/include/grpc++/impl/call.h index 40dbf9e641..88056470e3 100644 --- a/include/grpc++/impl/call.h +++ b/include/grpc++/impl/call.h @@ -54,7 +54,8 @@ class Call; void FillMetadataMap(grpc_metadata_array* arr, std::multimap* metadata); -grpc_metadata* FillMetadataArray(const std::multimap& metadata); +grpc_metadata* FillMetadataArray( + const std::multimap& metadata); class CallNoOp { protected: @@ -66,7 +67,8 @@ class CallOpSendInitialMetadata { public: CallOpSendInitialMetadata() : send_(false) {} - void SendInitialMetadata(const std::multimap& metadata) { + void SendInitialMetadata( + const std::multimap& metadata) { send_ = true; initial_metadata_count_ = metadata.size(); initial_metadata_ = FillMetadataArray(metadata); @@ -118,16 +120,14 @@ class CallOpRecvMessage { public: CallOpRecvMessage() : got_message(false), message_(nullptr) {} - void RecvMessage(R* message) { - message_ = message; - } + void RecvMessage(R* message) { message_ = message; } bool got_message; protected: void AddOp(grpc_op* ops, size_t* nops) { if (message_ == nullptr) return; - grpc_op *op = &ops[(*nops)++]; + grpc_op* op = &ops[(*nops)++]; op->op = GRPC_OP_RECV_MESSAGE; op->data.recv_message = &recv_buf_; } @@ -137,7 +137,9 @@ class CallOpRecvMessage { if (recv_buf_) { if (*status) { got_message = true; - *status = SerializationTraits::Deserialize(recv_buf_, message_, max_message_size).IsOk(); + *status = SerializationTraits::Deserialize(recv_buf_, message_, + max_message_size) + .IsOk(); } else { got_message = false; grpc_byte_buffer_destroy(recv_buf_); @@ -159,8 +161,10 @@ class CallOpGenericRecvMessage { template void RecvMessage(R* message) { - deserialize_ = [message](grpc_byte_buffer* buf, int max_message_size) -> Status { - return SerializationTraits::Deserialize(buf, message, max_message_size); + deserialize_ = [message](grpc_byte_buffer* buf, + int max_message_size) -> Status { + return SerializationTraits::Deserialize(buf, message, + max_message_size); }; } @@ -169,7 +173,7 @@ class CallOpGenericRecvMessage { protected: void AddOp(grpc_op* ops, size_t* nops) { if (!deserialize_) return; - grpc_op *op = &ops[(*nops)++]; + grpc_op* op = &ops[(*nops)++]; op->op = GRPC_OP_RECV_MESSAGE; op->data.recv_message = &recv_buf_; } @@ -218,7 +222,9 @@ class CallOpServerSendStatus { public: CallOpServerSendStatus() : send_status_available_(false) {} - void ServerSendStatus(const std::multimap& trailing_metadata, const Status& status){ + void ServerSendStatus( + const std::multimap& trailing_metadata, + const Status& status) { trailing_metadata_count_ = trailing_metadata.size(); trailing_metadata_ = FillMetadataArray(trailing_metadata); send_status_available_ = true; @@ -232,8 +238,7 @@ class CallOpServerSendStatus { op->op = GRPC_OP_SEND_STATUS_FROM_SERVER; op->data.send_status_from_server.trailing_metadata_count = trailing_metadata_count_; - op->data.send_status_from_server.trailing_metadata = - trailing_metadata_; + op->data.send_status_from_server.trailing_metadata = trailing_metadata_; op->data.send_status_from_server.status = send_status_code_; op->data.send_status_from_server.status_details = send_status_details_.empty() ? nullptr : send_status_details_.c_str(); @@ -280,9 +285,7 @@ class CallOpRecvInitialMetadata { class CallOpClientRecvStatus { public: - CallOpClientRecvStatus() { - memset(this, 0, sizeof(*this)); - } + CallOpClientRecvStatus() { memset(this, 0, sizeof(*this)); } void ClientRecvStatus(ClientContext* context, Status* status) { recv_trailing_metadata_ = &context->trailing_metadata_; @@ -323,7 +326,9 @@ class CallOpSetInterface : public CompletionQueueTag { CallOpSetInterface() : max_message_size_(0) {} virtual void FillOps(grpc_op* ops, size_t* nops) = 0; - void set_max_message_size(int max_message_size) { max_message_size_ = max_message_size; } + void set_max_message_size(int max_message_size) { + max_message_size_ = max_message_size; + } protected: int max_message_size_; @@ -332,14 +337,15 @@ class CallOpSetInterface : public CompletionQueueTag { template class WrapAndDerive : public T {}; -template -class CallOpSet : public CallOpSetInterface, -public WrapAndDerive, -public WrapAndDerive, -public WrapAndDerive, -public WrapAndDerive, -public WrapAndDerive, -public WrapAndDerive { +template +class CallOpSet : public CallOpSetInterface, + public WrapAndDerive, + public WrapAndDerive, + public WrapAndDerive, + public WrapAndDerive, + public WrapAndDerive, + public WrapAndDerive { public: CallOpSet() : return_tag_(this) {} void FillOps(grpc_op* ops, size_t* nops) GRPC_OVERRIDE { @@ -365,7 +371,7 @@ public WrapAndDerive { void set_output_tag(void* return_tag) { return_tag_ = return_tag; } private: - void *return_tag_; + void* return_tag_; }; #if 0 @@ -444,11 +450,15 @@ class CallOpBuffer : public CompletionQueueTag { #endif // SneakyCallOpBuffer does not post completions to the completion queue -template -class SneakyCallOpSet GRPC_FINAL : public CallOpSet { +template +class SneakyCallOpSet GRPC_FINAL + : public CallOpSet { public: bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { - return CallOpSet::FinalizeResult(tag, status) && false; + return CallOpSet::FinalizeResult(tag, + status) && + false; } }; diff --git a/include/grpc++/impl/client_unary_call.h b/include/grpc++/impl/client_unary_call.h index 5e37e63c6d..c1832f9eb8 100644 --- a/include/grpc++/impl/client_unary_call.h +++ b/include/grpc++/impl/client_unary_call.h @@ -49,18 +49,13 @@ class Status; // Wrapper that performs a blocking unary call template Status BlockingUnaryCall(ChannelInterface* channel, const RpcMethod& method, - ClientContext* context, - const InputMessage& request, + ClientContext* context, const InputMessage& request, OutputMessage* result) { CompletionQueue cq; Call call(channel->CreateCall(method, context, &cq)); - CallOpSet< - CallOpSendInitialMetadata, - CallOpSendMessage, - CallOpRecvInitialMetadata, - CallOpRecvMessage, - CallOpClientSendClose, - CallOpClientRecvStatus> ops; + CallOpSet, + CallOpClientSendClose, CallOpClientRecvStatus> ops; Status status; ops.SendInitialMetadata(context->send_initial_metadata_); if (!ops.SendMessage(request)) { diff --git a/include/grpc++/impl/proto_utils.h b/include/grpc++/impl/proto_utils.h index 1a0cc31a8a..ee19859198 100644 --- a/include/grpc++/impl/proto_utils.h +++ b/include/grpc++/impl/proto_utils.h @@ -55,14 +55,18 @@ Status DeserializeProto(grpc_byte_buffer* buffer, grpc::protobuf::Message* msg, int max_message_size); template -class SerializationTraits::value>::type> { +class SerializationTraits::value>::type> { public: - static bool Serialize(const grpc::protobuf::Message& msg, grpc_byte_buffer** buffer) { - return SerializeProto(msg, buffer); - } - static Status Deserialize(grpc_byte_buffer* buffer, grpc::protobuf::Message* msg, int max_message_size) { - return DeserializeProto(buffer, msg, max_message_size); - } + static bool Serialize(const grpc::protobuf::Message& msg, + grpc_byte_buffer** buffer) { + return SerializeProto(msg, buffer); + } + static Status Deserialize(grpc_byte_buffer* buffer, + grpc::protobuf::Message* msg, + int max_message_size) { + return DeserializeProto(buffer, msg, max_message_size); + } }; } // namespace grpc diff --git a/include/grpc++/impl/rpc_service_method.h b/include/grpc++/impl/rpc_service_method.h index cd31b22323..1bf39fca3b 100644 --- a/include/grpc++/impl/rpc_service_method.h +++ b/include/grpc++/impl/rpc_service_method.h @@ -55,9 +55,12 @@ class MethodHandler { public: virtual ~MethodHandler() {} struct HandlerParameter { - HandlerParameter(Call* c, ServerContext* context, - grpc_byte_buffer* req, int max_size) - : call(c), server_context(context), request(req), max_message_size(max_size) {} + HandlerParameter(Call* c, ServerContext* context, grpc_byte_buffer* req, + int max_size) + : call(c), + server_context(context), + request(req), + max_message_size(max_size) {} Call* call; ServerContext* server_context; // Handler required to grpc_byte_buffer_destroy this @@ -79,14 +82,16 @@ class RpcMethodHandler : public MethodHandler { void RunHandler(const HandlerParameter& param) GRPC_FINAL { RequestType req; - Status status = SerializationTraits::Deserialize(param.request, &req, param.max_message_size); + Status status = SerializationTraits::Deserialize( + param.request, &req, param.max_message_size); ResponseType rsp; if (status.IsOk()) { status = func_(service_, param.server_context, &req, &rsp); } GPR_ASSERT(!param.server_context->sent_initial_metadata_); - CallOpSet ops; + CallOpSet ops; ops.SendInitialMetadata(param.server_context->initial_metadata_); if (status.IsOk()) { if (!ops.SendMessage(rsp)) { @@ -122,7 +127,8 @@ class ClientStreamingHandler : public MethodHandler { Status status = func_(service_, param.server_context, &reader, &rsp); GPR_ASSERT(!param.server_context->sent_initial_metadata_); - CallOpSet ops; + CallOpSet ops; ops.SendInitialMetadata(param.server_context->initial_metadata_); if (status.IsOk()) { if (!ops.SendMessage(rsp)) { @@ -152,7 +158,8 @@ class ServerStreamingHandler : public MethodHandler { void RunHandler(const HandlerParameter& param) GRPC_FINAL { RequestType req; - Status status = SerializationTraits::Deserialize(param.request, &req, param.max_message_size); + Status status = SerializationTraits::Deserialize( + param.request, &req, param.max_message_size); if (status.IsOk()) { ServerWriter writer(param.call, param.server_context); @@ -211,8 +218,7 @@ class RpcServiceMethod : public RpcMethod { // Takes ownership of the handler RpcServiceMethod(const char* name, RpcMethod::RpcType type, MethodHandler* handler) - : RpcMethod(name, type, nullptr), - handler_(handler) {} + : RpcMethod(name, type, nullptr), handler_(handler) {} MethodHandler* handler() { return handler_.get(); } diff --git a/include/grpc++/impl/serialization_traits.h b/include/grpc++/impl/serialization_traits.h index 4648bbfc33..e4f086e08d 100644 --- a/include/grpc++/impl/serialization_traits.h +++ b/include/grpc++/impl/serialization_traits.h @@ -38,9 +38,10 @@ struct grpc_byte_buffer; namespace grpc { -template +template class SerializationTraits; } // namespace grpc -#endif // GRPCXX_IMPL_SERIALIZATION_TRAITS_H +#endif // GRPCXX_IMPL_SERIALIZATION_TRAITS_H diff --git a/include/grpc++/impl/service_type.h b/include/grpc++/impl/service_type.h index af21d9b8cf..8f9f38f193 100644 --- a/include/grpc++/impl/service_type.h +++ b/include/grpc++/impl/service_type.h @@ -77,21 +77,20 @@ class AsynchronousService { protected: template - void RequestAsyncUnary(int index, ServerContext* context, - Message* request, + void RequestAsyncUnary(int index, ServerContext* context, Message* request, ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, ServerCompletionQueue* notification_cq, void* tag) { - server_->RequestAsyncCall(request_args_[index], context, - stream, call_cq, notification_cq, tag, request); + server_->RequestAsyncCall(request_args_[index], context, stream, call_cq, + notification_cq, tag, request); } void RequestClientStreaming(int index, ServerContext* context, ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, ServerCompletionQueue* notification_cq, void* tag) { - server_->RequestAsyncCall(request_args_[index], context, - stream, call_cq, notification_cq, tag); + server_->RequestAsyncCall(request_args_[index], context, stream, call_cq, + notification_cq, tag); } template void RequestServerStreaming(int index, ServerContext* context, @@ -100,15 +99,15 @@ class AsynchronousService { CompletionQueue* call_cq, ServerCompletionQueue* notification_cq, void* tag) { - server_->RequestAsyncCall(request_args_[index], context, - stream, call_cq, notification_cq, tag, request); + server_->RequestAsyncCall(request_args_[index], context, stream, call_cq, + notification_cq, tag, request); } void RequestBidiStreaming(int index, ServerContext* context, ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, ServerCompletionQueue* notification_cq, void* tag) { - server_->RequestAsyncCall(request_args_[index], context, - stream, call_cq, notification_cq, tag); + server_->RequestAsyncCall(request_args_[index], context, stream, call_cq, + notification_cq, tag); } private: diff --git a/include/grpc++/server.h b/include/grpc++/server.h index a6883e24e6..8c7551ccf1 100644 --- a/include/grpc++/server.h +++ b/include/grpc++/server.h @@ -58,8 +58,7 @@ class ServerCredentials; class ThreadPoolInterface; // Currently it only supports handling rpcs in a single thread. -class Server GRPC_FINAL : public GrpcLibrary, - private CallHook { +class Server GRPC_FINAL : public GrpcLibrary, private CallHook { public: ~Server(); @@ -97,14 +96,13 @@ class Server GRPC_FINAL : public GrpcLibrary, void RunRpc(); void ScheduleCallback(); - void PerformOpsOnCall(CallOpSetInterface *ops, Call* call) GRPC_OVERRIDE; + void PerformOpsOnCall(CallOpSetInterface* ops, Call* call) GRPC_OVERRIDE; class BaseAsyncRequest : public CompletionQueueTag { public: BaseAsyncRequest(Server* server, ServerContext* context, - ServerAsyncStreamingInterface* stream, - CompletionQueue* call_cq, - void* tag); + ServerAsyncStreamingInterface* stream, + CompletionQueue* call_cq, void* tag); virtual ~BaseAsyncRequest(); bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE; @@ -123,20 +121,24 @@ class Server GRPC_FINAL : public GrpcLibrary, class RegisteredAsyncRequest : public BaseAsyncRequest { public: RegisteredAsyncRequest(Server* server, ServerContext* context, - ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, void* tag); + ServerAsyncStreamingInterface* stream, + CompletionQueue* call_cq, void* tag); // uses BaseAsyncRequest::FinalizeResult protected: - void IssueRequest(void* registered_method, grpc_byte_buffer** payload, ServerCompletionQueue *notification_cq); + void IssueRequest(void* registered_method, grpc_byte_buffer** payload, + ServerCompletionQueue* notification_cq); }; class NoPayloadAsyncRequest GRPC_FINAL : public RegisteredAsyncRequest { public: - NoPayloadAsyncRequest(void* registered_method, Server* server, ServerContext* context, - ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, - ServerCompletionQueue* notification_cq, void* tag) - : RegisteredAsyncRequest(server, context, stream, call_cq, tag) { + NoPayloadAsyncRequest(void* registered_method, Server* server, + ServerContext* context, + ServerAsyncStreamingInterface* stream, + CompletionQueue* call_cq, + ServerCompletionQueue* notification_cq, void* tag) + : RegisteredAsyncRequest(server, context, stream, call_cq, tag) { IssueRequest(registered_method, nullptr, notification_cq); } @@ -146,15 +148,23 @@ class Server GRPC_FINAL : public GrpcLibrary, template class PayloadAsyncRequest GRPC_FINAL : public RegisteredAsyncRequest { public: - PayloadAsyncRequest(void* registered_method, Server* server, ServerContext* context, - ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, - ServerCompletionQueue* notification_cq, void* tag, Message* request) - : RegisteredAsyncRequest(server, context, stream, call_cq, tag), request_(request) { + PayloadAsyncRequest(void* registered_method, Server* server, + ServerContext* context, + ServerAsyncStreamingInterface* stream, + CompletionQueue* call_cq, + ServerCompletionQueue* notification_cq, void* tag, + Message* request) + : RegisteredAsyncRequest(server, context, stream, call_cq, tag), + request_(request) { IssueRequest(registered_method, &payload_, notification_cq); } bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { - bool serialization_status = *status && payload_ && SerializationTraits::Deserialize(payload_, request_, server_->max_message_size_).IsOk(); + bool serialization_status = + *status && payload_ && + SerializationTraits::Deserialize(payload_, request_, + server_->max_message_size_) + .IsOk(); bool ret = RegisteredAsyncRequest::FinalizeResult(tag, status); *status = serialization_status && *status; return ret; @@ -168,10 +178,9 @@ class Server GRPC_FINAL : public GrpcLibrary, class GenericAsyncRequest GRPC_FINAL : public BaseAsyncRequest { public: GenericAsyncRequest(Server* server, GenericServerContext* context, - ServerAsyncStreamingInterface* stream, - CompletionQueue* call_cq, - ServerCompletionQueue* notification_cq, - void* tag); + ServerAsyncStreamingInterface* stream, + CompletionQueue* call_cq, + ServerCompletionQueue* notification_cq, void* tag); bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE; @@ -183,17 +192,18 @@ class Server GRPC_FINAL : public GrpcLibrary, void RequestAsyncCall(void* registered_method, ServerContext* context, ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, - ServerCompletionQueue* notification_cq, - void* tag, Message *message) { - new PayloadAsyncRequest(registered_method, this, context, stream, call_cq, notification_cq, tag, message); + ServerCompletionQueue* notification_cq, void* tag, + Message* message) { + new PayloadAsyncRequest(registered_method, this, context, stream, + call_cq, notification_cq, tag, message); } void RequestAsyncCall(void* registered_method, ServerContext* context, ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, - ServerCompletionQueue* notification_cq, - void* tag) { - new NoPayloadAsyncRequest(registered_method, this, context, stream, call_cq, notification_cq, tag); + ServerCompletionQueue* notification_cq, void* tag) { + new NoPayloadAsyncRequest(registered_method, this, context, stream, call_cq, + notification_cq, tag); } void RequestAsyncGenericCall(GenericServerContext* context, @@ -201,7 +211,8 @@ class Server GRPC_FINAL : public GrpcLibrary, CompletionQueue* call_cq, ServerCompletionQueue* notification_cq, void* tag) { - new GenericAsyncRequest(this, context, stream, call_cq, notification_cq, tag); + new GenericAsyncRequest(this, context, stream, call_cq, notification_cq, + tag); } const int max_message_size_; diff --git a/include/grpc++/stream.h b/include/grpc++/stream.h index eb2bce678f..2495f96abf 100644 --- a/include/grpc++/stream.h +++ b/include/grpc++/stream.h @@ -97,7 +97,8 @@ class ClientReader GRPC_FINAL : public ClientReaderInterface { ClientReader(ChannelInterface* channel, const RpcMethod& method, ClientContext* context, const W& request) : context_(context), call_(channel->CreateCall(method, context, &cq_)) { - CallOpSet ops; + CallOpSet ops; ops.SendInitialMetadata(context->send_initial_metadata_); // TODO(ctiller): don't assert GPR_ASSERT(ops.SendMessage(request)); @@ -158,8 +159,7 @@ class ClientWriter : public ClientWriterInterface { template ClientWriter(ChannelInterface* channel, const RpcMethod& method, ClientContext* context, R* response) - : context_(context), - call_(channel->CreateCall(method, context, &cq_)) { + : context_(context), call_(channel->CreateCall(method, context, &cq_)) { finish_ops_.RecvMessage(response); CallOpSet ops; @@ -408,8 +408,7 @@ class AsyncWriterInterface { template class ClientAsyncReaderInterface : public ClientAsyncStreamingInterface, - public AsyncReaderInterface { -}; + public AsyncReaderInterface {}; template class ClientAsyncReader GRPC_FINAL : public ClientAsyncReaderInterface { @@ -457,7 +456,8 @@ class ClientAsyncReader GRPC_FINAL : public ClientAsyncReaderInterface { private: ClientContext* context_; Call call_; - CallOpSet init_ops_; + CallOpSet + init_ops_; CallOpSet meta_ops_; CallOpSet> read_ops_; CallOpSet finish_ops_; @@ -477,8 +477,7 @@ class ClientAsyncWriter GRPC_FINAL : public ClientAsyncWriterInterface { ClientAsyncWriter(ChannelInterface* channel, CompletionQueue* cq, const RpcMethod& method, ClientContext* context, R* response, void* tag) - : context_(context), - call_(channel->CreateCall(method, context, cq)) { + : context_(context), call_(channel->CreateCall(method, context, cq)) { finish_ops_.RecvMessage(response); init_ops_.set_output_tag(tag); @@ -523,7 +522,8 @@ class ClientAsyncWriter GRPC_FINAL : public ClientAsyncWriterInterface { CallOpSet meta_ops_; CallOpSet write_ops_; CallOpSet writes_done_ops_; - CallOpSet finish_ops_; + CallOpSet finish_ops_; }; // Client-side interface for bi-directional streaming. @@ -628,7 +628,9 @@ class ServerAsyncReader GRPC_FINAL : public ServerAsyncStreamingInterface, } // The response is dropped if the status is not OK. if (status.IsOk() && !finish_ops_.SendMessage(msg)) { - finish_ops_.ServerSendStatus(ctx_->trailing_metadata_, Status(INTERNAL, "Failed to serialize response")); + finish_ops_.ServerSendStatus( + ctx_->trailing_metadata_, + Status(INTERNAL, "Failed to serialize response")); } else { finish_ops_.ServerSendStatus(ctx_->trailing_metadata_, status); } @@ -653,7 +655,8 @@ class ServerAsyncReader GRPC_FINAL : public ServerAsyncStreamingInterface, ServerContext* ctx_; CallOpSet meta_ops_; CallOpSet> read_ops_; - CallOpSet finish_ops_; + CallOpSet finish_ops_; }; template diff --git a/include/grpc/support/port_platform.h b/include/grpc/support/port_platform.h index 077eeb1c07..4fbce9c8d9 100644 --- a/include/grpc/support/port_platform.h +++ b/include/grpc/support/port_platform.h @@ -223,7 +223,9 @@ #endif /* Validate platform combinations */ -#if defined(GPR_GCC_ATOMIC) + defined(GPR_GCC_SYNC) + defined(GPR_WIN32_ATOMIC) != 1 +#if defined(GPR_GCC_ATOMIC) + defined(GPR_GCC_SYNC) + \ + defined(GPR_WIN32_ATOMIC) != \ + 1 #error Must define exactly one of GPR_GCC_ATOMIC, GPR_GCC_SYNC, GPR_WIN32_ATOMIC #endif @@ -231,7 +233,9 @@ #error Must define exactly one of GPR_ARCH_32, GPR_ARCH_64 #endif -#if defined(GPR_CPU_LINUX) + defined(GPR_CPU_POSIX) + defined(GPR_WIN32) + defined(GPR_CPU_IPHONE) + defined(GPR_CPU_CUSTOM) != 1 +#if defined(GPR_CPU_LINUX) + defined(GPR_CPU_POSIX) + defined(GPR_WIN32) + \ + defined(GPR_CPU_IPHONE) + defined(GPR_CPU_CUSTOM) != \ + 1 #error Must define exactly one of GPR_CPU_LINUX, GPR_CPU_POSIX, GPR_WIN32, GPR_CPU_IPHONE, GPR_CPU_CUSTOM #endif @@ -239,11 +243,15 @@ #error Must define GPR_POSIX_SOCKET to use GPR_POSIX_MULTIPOLL_WITH_POLL #endif -#if defined(GPR_POSIX_SOCKET) + defined(GPR_WINSOCK_SOCKET) + defined(GPR_CUSTOM_SOCKET) != 1 +#if defined(GPR_POSIX_SOCKET) + defined(GPR_WINSOCK_SOCKET) + \ + defined(GPR_CUSTOM_SOCKET) != \ + 1 #error Must define exactly one of GPR_POSIX_SOCKET, GPR_WINSOCK_SOCKET, GPR_CUSTOM_SOCKET #endif -#if defined(GPR_MSVC_TLS) + defined(GPR_GCC_TLS) + defined(GPR_PTHREAD_TLS) + defined(GPR_CUSTOM_TLS) != 1 +#if defined(GPR_MSVC_TLS) + defined(GPR_GCC_TLS) + defined(GPR_PTHREAD_TLS) + \ + defined(GPR_CUSTOM_TLS) != \ + 1 #error Must define exactly one of GPR_MSVC_TLS, GPR_GCC_TLS, GPR_PTHREAD_TLS, GPR_CUSTOM_TLS #endif @@ -268,10 +276,10 @@ typedef uintptr_t gpr_uintptr; #ifndef GRPC_MUST_USE_RESULT #ifdef __GNUC__ -#define GRPC_MUST_USE_RESULT __attribute__ ((warn_unused_result)) +#define GRPC_MUST_USE_RESULT __attribute__((warn_unused_result)) #else #define GRPC_MUST_USE_RESULT #endif #endif -#endif /* GRPC_SUPPORT_PORT_PLATFORM_H */ +#endif /* GRPC_SUPPORT_PORT_PLATFORM_H */ diff --git a/src/compiler/config.h b/src/compiler/config.h index 06ccd8530c..cd52aca57d 100644 --- a/src/compiler/config.h +++ b/src/compiler/config.h @@ -49,7 +49,8 @@ #ifndef GRPC_CUSTOM_CODEGENERATOR #include #define GRPC_CUSTOM_CODEGENERATOR ::google::protobuf::compiler::CodeGenerator -#define GRPC_CUSTOM_GENERATORCONTEXT ::google::protobuf::compiler::GeneratorContext +#define GRPC_CUSTOM_GENERATORCONTEXT \ + ::google::protobuf::compiler::GeneratorContext #endif #ifndef GRPC_CUSTOM_PRINTER @@ -58,7 +59,8 @@ #include #define GRPC_CUSTOM_PRINTER ::google::protobuf::io::Printer #define GRPC_CUSTOM_CODEDOUTPUTSTREAM ::google::protobuf::io::CodedOutputStream -#define GRPC_CUSTOM_STRINGOUTPUTSTREAM ::google::protobuf::io::StringOutputStream +#define GRPC_CUSTOM_STRINGOUTPUTSTREAM \ + ::google::protobuf::io::StringOutputStream #endif #ifndef GRPC_CUSTOM_PLUGINMAIN diff --git a/src/compiler/cpp_generator.cc b/src/compiler/cpp_generator.cc index d03eaddf40..0b69848f7d 100644 --- a/src/compiler/cpp_generator.cc +++ b/src/compiler/cpp_generator.cc @@ -97,7 +97,8 @@ grpc::string GetHeaderPrologue(const grpc::protobuf::FileDescriptor *file, vars["filename_base"] = grpc_generator::StripProto(file->name()); printer.Print(vars, "// Generated by the gRPC protobuf plugin.\n"); - printer.Print(vars, "// If you make any local change, they will be lost.\n"); + printer.Print(vars, + "// If you make any local change, they will be lost.\n"); printer.Print(vars, "// source: $filename$\n"); printer.Print(vars, "#ifndef GRPC_$filename_identifier$__INCLUDED\n"); printer.Print(vars, "#define GRPC_$filename_identifier$__INCLUDED\n"); @@ -142,10 +143,10 @@ grpc::string GetHeaderIncludes(const grpc::protobuf::FileDescriptor *file, return temp; } -void PrintHeaderClientMethodInterfaces(grpc::protobuf::io::Printer *printer, - const grpc::protobuf::MethodDescriptor *method, - std::map *vars, - bool is_public) { +void PrintHeaderClientMethodInterfaces( + grpc::protobuf::io::Printer *printer, + const grpc::protobuf::MethodDescriptor *method, + std::map *vars, bool is_public) { (*vars)["Method"] = method->name(); (*vars)["Request"] = grpc_cpp_generator::ClassName(method->input_type(), true); @@ -158,19 +159,17 @@ void PrintHeaderClientMethodInterfaces(grpc::protobuf::io::Printer *printer, *vars, "virtual ::grpc::Status $Method$(::grpc::ClientContext* context, " "const $Request$& request, $Response$* response) = 0;\n"); - printer->Print( - *vars, - "std::unique_ptr< " - "::grpc::ClientAsyncResponseReaderInterface< $Response$>> " - "Async$Method$(::grpc::ClientContext* context, " - "const $Request$& request, " - "::grpc::CompletionQueue* cq) {\n"); + printer->Print(*vars, + "std::unique_ptr< " + "::grpc::ClientAsyncResponseReaderInterface< $Response$>> " + "Async$Method$(::grpc::ClientContext* context, " + "const $Request$& request, " + "::grpc::CompletionQueue* cq) {\n"); printer->Indent(); - printer->Print( - *vars, - "return std::unique_ptr< " - "::grpc::ClientAsyncResponseReaderInterface< $Response$>>(" - "Async$Method$Raw(context, request, cq));\n"); + printer->Print(*vars, + "return std::unique_ptr< " + "::grpc::ClientAsyncResponseReaderInterface< $Response$>>(" + "Async$Method$Raw(context, request, cq));\n"); printer->Outdent(); printer->Print("}\n"); } else if (ClientOnlyStreaming(method)) { @@ -189,14 +188,14 @@ void PrintHeaderClientMethodInterfaces(grpc::protobuf::io::Printer *printer, printer->Print( *vars, "std::unique_ptr< ::grpc::ClientAsyncWriterInterface< $Request$>>" - " Async$Method$(::grpc::ClientContext* context, $Response$* response, " + " Async$Method$(::grpc::ClientContext* context, $Response$* " + "response, " "::grpc::CompletionQueue* cq, void* tag) {\n"); printer->Indent(); - printer->Print( - *vars, - "return std::unique_ptr< " - "::grpc::ClientAsyncWriterInterface< $Request$>>(" - "Async$Method$Raw(context, response, cq, tag));\n"); + printer->Print(*vars, + "return std::unique_ptr< " + "::grpc::ClientAsyncWriterInterface< $Request$>>(" + "Async$Method$Raw(context, response, cq, tag));\n"); printer->Outdent(); printer->Print("}\n"); } else if (ServerOnlyStreaming(method)) { @@ -219,18 +218,17 @@ void PrintHeaderClientMethodInterfaces(grpc::protobuf::io::Printer *printer, "::grpc::ClientContext* context, const $Request$& request, " "::grpc::CompletionQueue* cq, void* tag) {\n"); printer->Indent(); - printer->Print( - *vars, - "return std::unique_ptr< " - "::grpc::ClientAsyncReaderInterface< $Response$>>(" - "Async$Method$Raw(context, request, cq, tag));\n"); + printer->Print(*vars, + "return std::unique_ptr< " + "::grpc::ClientAsyncReaderInterface< $Response$>>(" + "Async$Method$Raw(context, request, cq, tag));\n"); printer->Outdent(); printer->Print("}\n"); } else if (BidiStreaming(method)) { - printer->Print( - *vars, - "std::unique_ptr< ::grpc::ClientReaderWriterInterface< $Request$, $Response$>> " - "$Method$(::grpc::ClientContext* context) {\n"); + printer->Print(*vars, + "std::unique_ptr< ::grpc::ClientReaderWriterInterface< " + "$Request$, $Response$>> " + "$Method$(::grpc::ClientContext* context) {\n"); printer->Indent(); printer->Print( *vars, @@ -268,12 +266,11 @@ void PrintHeaderClientMethodInterfaces(grpc::protobuf::io::Printer *printer, "virtual ::grpc::ClientWriterInterface< $Request$>*" " $Method$Raw(" "::grpc::ClientContext* context, $Response$* response) = 0;\n"); - printer->Print( - *vars, - "virtual ::grpc::ClientAsyncWriterInterface< $Request$>*" - " Async$Method$Raw(::grpc::ClientContext* context, " - "$Response$* response, " - "::grpc::CompletionQueue* cq, void* tag) = 0;\n"); + printer->Print(*vars, + "virtual ::grpc::ClientAsyncWriterInterface< $Request$>*" + " Async$Method$Raw(::grpc::ClientContext* context, " + "$Response$* response, " + "::grpc::CompletionQueue* cq, void* tag) = 0;\n"); } else if (ServerOnlyStreaming(method)) { printer->Print( *vars, @@ -286,16 +283,15 @@ void PrintHeaderClientMethodInterfaces(grpc::protobuf::io::Printer *printer, "::grpc::ClientContext* context, const $Request$& request, " "::grpc::CompletionQueue* cq, void* tag) = 0;\n"); } else if (BidiStreaming(method)) { - printer->Print( - *vars, - "virtual ::grpc::ClientReaderWriterInterface< $Request$, $Response$>* " - "$Method$Raw(::grpc::ClientContext* context) = 0;\n"); - printer->Print( - *vars, - "virtual ::grpc::ClientAsyncReaderWriterInterface< " - "$Request$, $Response$>* " - "Async$Method$Raw(::grpc::ClientContext* context, " - "::grpc::CompletionQueue* cq, void* tag) = 0;\n"); + printer->Print(*vars, + "virtual ::grpc::ClientReaderWriterInterface< $Request$, " + "$Response$>* " + "$Method$Raw(::grpc::ClientContext* context) = 0;\n"); + printer->Print(*vars, + "virtual ::grpc::ClientAsyncReaderWriterInterface< " + "$Request$, $Response$>* " + "Async$Method$Raw(::grpc::ClientContext* context, " + "::grpc::CompletionQueue* cq, void* tag) = 0;\n"); } } } @@ -322,11 +318,10 @@ void PrintHeaderClientMethod(grpc::protobuf::io::Printer *printer, "const $Request$& request, " "::grpc::CompletionQueue* cq) {\n"); printer->Indent(); - printer->Print( - *vars, - "return std::unique_ptr< " - "::grpc::ClientAsyncResponseReader< $Response$>>(" - "Async$Method$Raw(context, request, cq));\n"); + printer->Print(*vars, + "return std::unique_ptr< " + "::grpc::ClientAsyncResponseReader< $Response$>>(" + "Async$Method$Raw(context, request, cq));\n"); printer->Outdent(); printer->Print("}\n"); } else if (ClientOnlyStreaming(method)) { @@ -336,17 +331,16 @@ void PrintHeaderClientMethod(grpc::protobuf::io::Printer *printer, " $Method$(" "::grpc::ClientContext* context, $Response$* response) {\n"); printer->Indent(); - printer->Print( - *vars, - "return std::unique_ptr< ::grpc::ClientWriter< $Request$>>" - "($Method$Raw(context, response));\n"); + printer->Print(*vars, + "return std::unique_ptr< ::grpc::ClientWriter< $Request$>>" + "($Method$Raw(context, response));\n"); printer->Outdent(); printer->Print("}\n"); - printer->Print( - *vars, - "std::unique_ptr< ::grpc::ClientAsyncWriter< $Request$>>" - " Async$Method$(::grpc::ClientContext* context, $Response$* response, " - "::grpc::CompletionQueue* cq, void* tag) {\n"); + printer->Print(*vars, + "std::unique_ptr< ::grpc::ClientAsyncWriter< $Request$>>" + " Async$Method$(::grpc::ClientContext* context, " + "$Response$* response, " + "::grpc::CompletionQueue* cq, void* tag) {\n"); printer->Indent(); printer->Print( *vars, @@ -386,53 +380,47 @@ void PrintHeaderClientMethod(grpc::protobuf::io::Printer *printer, "std::unique_ptr< ::grpc::ClientReaderWriter< $Request$, $Response$>>" " $Method$(::grpc::ClientContext* context) {\n"); printer->Indent(); - printer->Print( - *vars, - "return std::unique_ptr< " - "::grpc::ClientReaderWriter< $Request$, $Response$>>(" - "$Method$Raw(context));\n"); + printer->Print(*vars, + "return std::unique_ptr< " + "::grpc::ClientReaderWriter< $Request$, $Response$>>(" + "$Method$Raw(context));\n"); printer->Outdent(); printer->Print("}\n"); - printer->Print( - *vars, - "std::unique_ptr< ::grpc::ClientAsyncReaderWriter< " - "$Request$, $Response$>> " - "Async$Method$(::grpc::ClientContext* context, " - "::grpc::CompletionQueue* cq, void* tag) {\n"); + printer->Print(*vars, + "std::unique_ptr< ::grpc::ClientAsyncReaderWriter< " + "$Request$, $Response$>> " + "Async$Method$(::grpc::ClientContext* context, " + "::grpc::CompletionQueue* cq, void* tag) {\n"); printer->Indent(); - printer->Print( - *vars, - "return std::unique_ptr< " - "::grpc::ClientAsyncReaderWriter< $Request$, $Response$>>(" - "Async$Method$Raw(context, cq, tag));\n"); + printer->Print(*vars, + "return std::unique_ptr< " + "::grpc::ClientAsyncReaderWriter< $Request$, $Response$>>(" + "Async$Method$Raw(context, cq, tag));\n"); printer->Outdent(); printer->Print("}\n"); } } else { if (NoStreaming(method)) { - printer->Print( - *vars, - "::grpc::ClientAsyncResponseReader< $Response$>* " - "Async$Method$Raw(::grpc::ClientContext* context, " - "const $Request$& request, " - "::grpc::CompletionQueue* cq) GRPC_OVERRIDE;\n"); + printer->Print(*vars, + "::grpc::ClientAsyncResponseReader< $Response$>* " + "Async$Method$Raw(::grpc::ClientContext* context, " + "const $Request$& request, " + "::grpc::CompletionQueue* cq) GRPC_OVERRIDE;\n"); } else if (ClientOnlyStreaming(method)) { - printer->Print( - *vars, - "::grpc::ClientWriter< $Request$>* $Method$Raw(" - "::grpc::ClientContext* context, $Response$* response) " - "GRPC_OVERRIDE;\n"); + printer->Print(*vars, + "::grpc::ClientWriter< $Request$>* $Method$Raw(" + "::grpc::ClientContext* context, $Response$* response) " + "GRPC_OVERRIDE;\n"); printer->Print( *vars, "::grpc::ClientAsyncWriter< $Request$>* Async$Method$Raw(" "::grpc::ClientContext* context, $Response$* response, " "::grpc::CompletionQueue* cq, void* tag) GRPC_OVERRIDE;\n"); } else if (ServerOnlyStreaming(method)) { - printer->Print( - *vars, - "::grpc::ClientReader< $Response$>* $Method$Raw(" - "::grpc::ClientContext* context, const $Request$& request)" - " GRPC_OVERRIDE;\n"); + printer->Print(*vars, + "::grpc::ClientReader< $Response$>* $Method$Raw(" + "::grpc::ClientContext* context, const $Request$& request)" + " GRPC_OVERRIDE;\n"); printer->Print( *vars, "::grpc::ClientAsyncReader< $Response$>* Async$Method$Raw(" @@ -630,7 +618,7 @@ grpc::string GetHeaderServices(const grpc::protobuf::FileDescriptor *file, const Parameters ¶ms) { grpc::string output; { - // Scope the output stream so it closes and finalizes output to the string. + // Scope the output stream so it closes and finalizes output to the string. grpc::protobuf::io::StringOutputStream output_stream(&output); grpc::protobuf::io::Printer printer(&output_stream, '$'); std::map vars; @@ -694,7 +682,8 @@ grpc::string GetSourcePrologue(const grpc::protobuf::FileDescriptor *file, vars["filename_base"] = grpc_generator::StripProto(file->name()); printer.Print(vars, "// Generated by the gRPC protobuf plugin.\n"); - printer.Print(vars, "// If you make any local change, they will be lost.\n"); + printer.Print(vars, + "// If you make any local change, they will be lost.\n"); printer.Print(vars, "// source: $filename$\n\n"); printer.Print(vars, "#include \"$filename_base$.pb.h\"\n"); printer.Print(vars, "#include \"$filename_base$.grpc.pb.h\"\n"); diff --git a/src/cpp/client/channel.h b/src/cpp/client/channel.h index 69baa419a6..9108713c58 100644 --- a/src/cpp/client/channel.h +++ b/src/cpp/client/channel.h @@ -50,16 +50,16 @@ class CompletionQueue; class Credentials; class StreamContextInterface; -class Channel GRPC_FINAL : public GrpcLibrary, - public ChannelInterface { +class Channel GRPC_FINAL : public GrpcLibrary, public ChannelInterface { public: Channel(const grpc::string& target, grpc_channel* c_channel); ~Channel() GRPC_OVERRIDE; - virtual void *RegisterMethod(const char *method) GRPC_OVERRIDE; + virtual void* RegisterMethod(const char* method) GRPC_OVERRIDE; virtual Call CreateCall(const RpcMethod& method, ClientContext* context, CompletionQueue* cq) GRPC_OVERRIDE; - virtual void PerformOpsOnCall(CallOpSetInterface* ops, Call* call) GRPC_OVERRIDE; + virtual void PerformOpsOnCall(CallOpSetInterface* ops, + Call* call) GRPC_OVERRIDE; private: const grpc::string target_; diff --git a/src/cpp/proto/proto_utils.cc b/src/cpp/proto/proto_utils.cc index a4a37c7000..9e8bf1a631 100644 --- a/src/cpp/proto/proto_utils.cc +++ b/src/cpp/proto/proto_utils.cc @@ -67,7 +67,7 @@ class GrpcBufferWriter GRPC_FINAL slice_ = gpr_slice_malloc(block_size_); } *data = GPR_SLICE_START_PTR(slice_); - byte_count_ += *size = GPR_SLICE_LENGTH(slice_); + byte_count_ += * size = GPR_SLICE_LENGTH(slice_); gpr_slice_buffer_add(slice_buffer_, slice_); return true; } @@ -118,7 +118,7 @@ class GrpcBufferReader GRPC_FINAL } gpr_slice_unref(slice_); *data = GPR_SLICE_START_PTR(slice_); - byte_count_ += *size = GPR_SLICE_LENGTH(slice_); + byte_count_ += * size = GPR_SLICE_LENGTH(slice_); return true; } @@ -158,7 +158,7 @@ bool SerializeProto(const grpc::protobuf::Message& msg, grpc_byte_buffer** bp) { } Status DeserializeProto(grpc_byte_buffer* buffer, grpc::protobuf::Message* msg, - int max_message_size) { + int max_message_size) { if (!buffer) { return Status(INVALID_ARGUMENT, "No payload"); } @@ -169,7 +169,7 @@ Status DeserializeProto(grpc_byte_buffer* buffer, grpc::protobuf::Message* msg, } if (!msg->ParseFromCodedStream(&decoder)) { return Status(INVALID_ARGUMENT, msg->InitializationErrorString()); - } + } if (!decoder.ConsumedEntireMessage()) { return Status(INVALID_ARGUMENT, "Did not read entire message"); } diff --git a/src/cpp/server/server.cc b/src/cpp/server/server.cc index bd97d707a7..b750868607 100644 --- a/src/cpp/server/server.cc +++ b/src/cpp/server/server.cc @@ -71,9 +71,7 @@ class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag { grpc_metadata_array_init(&request_metadata_); } - ~SyncRequest() { - grpc_metadata_array_destroy(&request_metadata_); - } + ~SyncRequest() { grpc_metadata_array_destroy(&request_metadata_); } static SyncRequest* Wait(CompletionQueue* cq, bool* ok) { void* tag = nullptr; @@ -129,8 +127,8 @@ class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag { void Run() { ctx_.BeginCompletionOp(&call_); - method_->handler()->RunHandler( - MethodHandler::HandlerParameter(&call_, &ctx_, request_payload_, call_.max_message_size())); + method_->handler()->RunHandler(MethodHandler::HandlerParameter( + &call_, &ctx_, request_payload_, call_.max_message_size())); void* ignored_tag; bool ignored_ok; cq_.Shutdown(); @@ -422,23 +420,27 @@ void Server::RequestAsyncGenericCall(GenericServerContext* context, } #endif -Server::BaseAsyncRequest::BaseAsyncRequest(Server* server, ServerContext* context, - ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, void* tag) -: server_(server), context_(context), stream_(stream), call_cq_(call_cq), call_(nullptr) { +Server::BaseAsyncRequest::BaseAsyncRequest( + Server* server, ServerContext* context, + ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, void* tag) + : server_(server), + context_(context), + stream_(stream), + call_cq_(call_cq), + call_(nullptr) { memset(&initial_metadata_array_, 0, sizeof(initial_metadata_array_)); } -Server::BaseAsyncRequest::~BaseAsyncRequest() { -} +Server::BaseAsyncRequest::~BaseAsyncRequest() {} bool Server::BaseAsyncRequest::FinalizeResult(void** tag, bool* status) { if (*status) { for (size_t i = 0; i < initial_metadata_array_.count; i++) { context_->client_metadata_.insert(std::make_pair( grpc::string(initial_metadata_array_.metadata[i].key), - grpc::string( - initial_metadata_array_.metadata[i].value, - initial_metadata_array_.metadata[i].value + initial_metadata_array_.metadata[i].value_length))); + grpc::string(initial_metadata_array_.metadata[i].value, + initial_metadata_array_.metadata[i].value + + initial_metadata_array_.metadata[i].value_length))); } } context_->call_ = call_; @@ -453,27 +455,31 @@ bool Server::BaseAsyncRequest::FinalizeResult(void** tag, bool* status) { return true; } -Server::RegisteredAsyncRequest::RegisteredAsyncRequest(Server* server, ServerContext* context, - ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, void* tag) +Server::RegisteredAsyncRequest::RegisteredAsyncRequest( + Server* server, ServerContext* context, + ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, void* tag) : BaseAsyncRequest(server, context, stream, call_cq, tag) {} - -void Server::RegisteredAsyncRequest::IssueRequest(void* registered_method, grpc_byte_buffer** payload, ServerCompletionQueue *notification_cq) { +void Server::RegisteredAsyncRequest::IssueRequest( + void* registered_method, grpc_byte_buffer** payload, + ServerCompletionQueue* notification_cq) { grpc_server_request_registered_call( - server_->server_, registered_method, &call_, &context_->deadline_, &initial_metadata_array_, payload, call_cq_->cq(), notification_cq->cq(), this); + server_->server_, registered_method, &call_, &context_->deadline_, + &initial_metadata_array_, payload, call_cq_->cq(), notification_cq->cq(), + this); } -Server::GenericAsyncRequest::GenericAsyncRequest(Server* server, GenericServerContext* context, - ServerAsyncStreamingInterface* stream, - CompletionQueue* call_cq, - ServerCompletionQueue* notification_cq, - void* tag) -: BaseAsyncRequest(server, context, stream, call_cq, tag) { +Server::GenericAsyncRequest::GenericAsyncRequest( + Server* server, GenericServerContext* context, + ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, + ServerCompletionQueue* notification_cq, void* tag) + : BaseAsyncRequest(server, context, stream, call_cq, tag) { grpc_call_details_init(&call_details_); GPR_ASSERT(notification_cq); GPR_ASSERT(call_cq); - grpc_server_request_call(server->server_, &call_, &call_details_, &initial_metadata_array_, - call_cq->cq(), notification_cq->cq(), this); + grpc_server_request_call(server->server_, &call_, &call_details_, + &initial_metadata_array_, call_cq->cq(), + notification_cq->cq(), this); } bool Server::GenericAsyncRequest::FinalizeResult(void** tag, bool* status) { -- cgit v1.2.3 From 5095581cdbd659c233873a23c12512e3f7d2f5bf Mon Sep 17 00:00:00 2001 From: Craig Tiller Date: Fri, 5 Jun 2015 08:03:17 -0700 Subject: Get server call tags right --- include/grpc++/server.h | 1 + src/cpp/server/server.cc | 2 ++ 2 files changed, 3 insertions(+) (limited to 'src/cpp/server') diff --git a/include/grpc++/server.h b/include/grpc++/server.h index 8c7551ccf1..cdfdc86587 100644 --- a/include/grpc++/server.h +++ b/include/grpc++/server.h @@ -114,6 +114,7 @@ class Server GRPC_FINAL : public GrpcLibrary, private CallHook { ServerContext* const context_; ServerAsyncStreamingInterface* const stream_; CompletionQueue* const call_cq_; + void* const tag_; grpc_call* call_; grpc_metadata_array initial_metadata_array_; }; diff --git a/src/cpp/server/server.cc b/src/cpp/server/server.cc index b750868607..eabfd86673 100644 --- a/src/cpp/server/server.cc +++ b/src/cpp/server/server.cc @@ -427,6 +427,7 @@ Server::BaseAsyncRequest::BaseAsyncRequest( context_(context), stream_(stream), call_cq_(call_cq), + tag_(tag), call_(nullptr) { memset(&initial_metadata_array_, 0, sizeof(initial_metadata_array_)); } @@ -451,6 +452,7 @@ bool Server::BaseAsyncRequest::FinalizeResult(void** tag, bool* status) { } // just the pointers inside call are copied here stream_->BindCall(&call); + *tag = tag_; delete this; return true; } -- cgit v1.2.3 From 3cb03ef0c8971f5598f629523448b23f71673281 Mon Sep 17 00:00:00 2001 From: Craig Tiller Date: Fri, 5 Jun 2015 08:09:41 -0700 Subject: Remove old code --- src/cpp/server/server.cc | 128 ----------------------------------------------- 1 file changed, 128 deletions(-) (limited to 'src/cpp/server') diff --git a/src/cpp/server/server.cc b/src/cpp/server/server.cc index eabfd86673..824b03e01e 100644 --- a/src/cpp/server/server.cc +++ b/src/cpp/server/server.cc @@ -292,134 +292,6 @@ void Server::PerformOpsOnCall(CallOpSetInterface* ops, Call* call) { grpc_call_start_batch(call->call(), cops, nops, ops)); } -#if 0 -class Server::AsyncRequest GRPC_FINAL : public CompletionQueueTag { - public: - AsyncRequest(Server* server, void* registered_method, ServerContext* ctx, - grpc::protobuf::Message* request, - ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, - ServerCompletionQueue* notification_cq, void* tag) - : tag_(tag), - request_(request), - stream_(stream), - call_cq_(call_cq), - ctx_(ctx), - generic_ctx_(nullptr), - server_(server), - call_(nullptr), - payload_(nullptr) { - memset(&array_, 0, sizeof(array_)); - grpc_call_details_init(&call_details_); - GPR_ASSERT(notification_cq); - GPR_ASSERT(call_cq); - grpc_server_request_registered_call( - server->server_, registered_method, &call_, &call_details_.deadline, - &array_, request ? &payload_ : nullptr, call_cq->cq(), - notification_cq->cq(), this); - } - - AsyncRequest() - : tag_(tag), - request_(nullptr), - stream_(stream), - call_cq_(call_cq), - ctx_(nullptr), - generic_ctx_(ctx), - server_(server), - call_(nullptr), - payload_(nullptr) { - memset(&array_, 0, sizeof(array_)); - grpc_call_details_init(&call_details_); - GPR_ASSERT(notification_cq); - GPR_ASSERT(call_cq); - grpc_server_request_call(server->server_, &call_, &call_details_, &array_, - call_cq->cq(), notification_cq->cq(), this); - } - - ~AsyncRequest() { - if (payload_) { - grpc_byte_buffer_destroy(payload_); - } - grpc_metadata_array_destroy(&array_); - } - - bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE { - *tag = tag_; - bool orig_status = *status; - if (*status && request_) { - if (payload_) { - GRPC_TIMER_BEGIN(GRPC_PTAG_PROTO_DESERIALIZE, call_); - *status = - DeserializeProto(payload_, request_, server_->max_message_size_); - GRPC_TIMER_END(GRPC_PTAG_PROTO_DESERIALIZE, call_); - } else { - *status = false; - } - } - ServerContext* ctx = ctx_ ? ctx_ : generic_ctx_; - GPR_ASSERT(ctx); - if (*status) { - ctx->deadline_ = call_details_.deadline; - for (size_t i = 0; i < array_.count; i++) { - ctx->client_metadata_.insert(std::make_pair( - grpc::string(array_.metadata[i].key), - grpc::string( - array_.metadata[i].value, - array_.metadata[i].value + array_.metadata[i].value_length))); - } - if (generic_ctx_) { - // TODO(yangg) remove the copy here. - generic_ctx_->method_ = call_details_.method; - generic_ctx_->host_ = call_details_.host; - gpr_free(call_details_.method); - gpr_free(call_details_.host); - } - } - ctx->call_ = call_; - ctx->cq_ = call_cq_; - Call call(call_, server_, call_cq_, server_->max_message_size_); - if (orig_status && call_) { - ctx->BeginCompletionOp(&call); - } - // just the pointers inside call are copied here - stream_->BindCall(&call); - delete this; - return true; - } - - private: - void* const tag_; - grpc::protobuf::Message* const request_; - ServerAsyncStreamingInterface* const stream_; - CompletionQueue* const call_cq_; - ServerContext* const ctx_; - GenericServerContext* const generic_ctx_; - Server* const server_; - grpc_call* call_; - grpc_call_details call_details_; - grpc_metadata_array array_; - grpc_byte_buffer* payload_; -}; - -void Server::RequestAsyncCall(void* registered_method, ServerContext* context, - grpc::protobuf::Message* request, - ServerAsyncStreamingInterface* stream, - CompletionQueue* call_cq, - ServerCompletionQueue* notification_cq, - void* tag) { - new AsyncRequest(this, registered_method, context, request, stream, call_cq, - notification_cq, tag); -} - -void Server::RequestAsyncGenericCall(GenericServerContext* context, - ServerAsyncStreamingInterface* stream, - CompletionQueue* call_cq, - ServerCompletionQueue* notification_cq, - void* tag) { - new AsyncRequest(this, context, stream, call_cq, notification_cq, tag); -} -#endif - Server::BaseAsyncRequest::BaseAsyncRequest( Server* server, ServerContext* context, ServerAsyncStreamingInterface* stream, CompletionQueue* call_cq, void* tag) -- cgit v1.2.3 From 928ec8ee51faf0e57fbc084d6da04d1f85704e07 Mon Sep 17 00:00:00 2001 From: Craig Tiller Date: Fri, 5 Jun 2015 08:45:45 -0700 Subject: Fix memory leak --- include/grpc++/impl/proto_utils.h | 5 ++++- src/cpp/server/server.cc | 1 + 2 files changed, 5 insertions(+), 1 deletion(-) (limited to 'src/cpp/server') diff --git a/include/grpc++/impl/proto_utils.h b/include/grpc++/impl/proto_utils.h index bf82f2b23d..9c5f60980a 100644 --- a/include/grpc++/impl/proto_utils.h +++ b/include/grpc++/impl/proto_utils.h @@ -36,6 +36,7 @@ #include +#include #include #include #include @@ -66,7 +67,9 @@ class SerializationTraitshandler()->RunHandler(MethodHandler::HandlerParameter( &call_, &ctx_, request_payload_, call_.max_message_size())); + request_payload_ = nullptr; void* ignored_tag; bool ignored_ok; cq_.Shutdown(); -- cgit v1.2.3 From 2f4a49c8d37be8468a9e2a37a33f187dc952e954 Mon Sep 17 00:00:00 2001 From: Craig Tiller Date: Fri, 5 Jun 2015 09:36:52 -0700 Subject: Fix memory leak --- include/grpc++/impl/call.h | 17 +++++++++++++---- include/grpc++/server.h | 2 -- src/cpp/server/server.cc | 1 + 3 files changed, 14 insertions(+), 6 deletions(-) (limited to 'src/cpp/server') diff --git a/include/grpc++/impl/call.h b/include/grpc++/impl/call.h index 94b0f915c6..9b07e2ac5e 100644 --- a/include/grpc++/impl/call.h +++ b/include/grpc++/impl/call.h @@ -34,7 +34,7 @@ #ifndef GRPCXX_IMPL_CALL_H #define GRPCXX_IMPL_CALL_H -#include +#include #include #include #include @@ -85,6 +85,8 @@ class CallOpSendInitialMetadata { op->data.send_initial_metadata.metadata = initial_metadata_; } void FinishOp(bool* status, int max_message_size) { + if (!send_) return; + gpr_free(initial_metadata_); send_ = false; } @@ -244,6 +246,7 @@ class CallOpServerSendStatus { protected: void AddOp(grpc_op* ops, size_t* nops) { + if (!send_status_available_) return; grpc_op* op = &ops[(*nops)++]; op->op = GRPC_OP_SEND_STATUS_FROM_SERVER; op->data.send_status_from_server.trailing_metadata_count = @@ -255,7 +258,9 @@ class CallOpServerSendStatus { } void FinishOp(bool* status, int max_message_size) { - send_status_details_ = false; + if (!send_status_available_) return; + gpr_free(trailing_metadata_); + send_status_available_ = false; } private: @@ -269,7 +274,6 @@ class CallOpServerSendStatus { class CallOpRecvInitialMetadata { public: CallOpRecvInitialMetadata() : recv_initial_metadata_(nullptr) { - memset(&recv_initial_metadata_arr_, 0, sizeof(recv_initial_metadata_arr_)); } void RecvInitialMetadata(ClientContext* context) { @@ -280,6 +284,7 @@ class CallOpRecvInitialMetadata { protected: void AddOp(grpc_op* ops, size_t* nops) { if (!recv_initial_metadata_) return; + memset(&recv_initial_metadata_arr_, 0, sizeof(recv_initial_metadata_arr_)); grpc_op* op = &ops[(*nops)++]; op->op = GRPC_OP_RECV_INITIAL_METADATA; op->data.recv_initial_metadata = &recv_initial_metadata_arr_; @@ -297,7 +302,7 @@ class CallOpRecvInitialMetadata { class CallOpClientRecvStatus { public: - CallOpClientRecvStatus() { memset(this, 0, sizeof(*this)); } + CallOpClientRecvStatus() : recv_status_(nullptr) {} void ClientRecvStatus(ClientContext* context, Status* status) { recv_trailing_metadata_ = &context->trailing_metadata_; @@ -307,6 +312,9 @@ class CallOpClientRecvStatus { protected: void AddOp(grpc_op* ops, size_t* nops) { if (recv_status_ == nullptr) return; + memset(&recv_trailing_metadata_arr_, 0, sizeof(recv_trailing_metadata_arr_)); + status_details_ = nullptr; + status_details_capacity_ = 0; grpc_op* op = &ops[(*nops)++]; op->op = GRPC_OP_RECV_STATUS_ON_CLIENT; op->data.recv_status_on_client.trailing_metadata = @@ -323,6 +331,7 @@ class CallOpClientRecvStatus { *recv_status_ = Status( static_cast(status_code_), status_details_ ? grpc::string(status_details_) : grpc::string()); + gpr_free(status_details_); recv_status_ = nullptr; } diff --git a/include/grpc++/server.h b/include/grpc++/server.h index cdfdc86587..834d19c882 100644 --- a/include/grpc++/server.h +++ b/include/grpc++/server.h @@ -108,8 +108,6 @@ class Server GRPC_FINAL : public GrpcLibrary, private CallHook { bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE; protected: - void FinalizeMetadata(ServerContext* context); - Server* const server_; ServerContext* const context_; ServerAsyncStreamingInterface* const stream_; diff --git a/src/cpp/server/server.cc b/src/cpp/server/server.cc index 680f96061c..ed1bb2a362 100644 --- a/src/cpp/server/server.cc +++ b/src/cpp/server/server.cc @@ -317,6 +317,7 @@ bool Server::BaseAsyncRequest::FinalizeResult(void** tag, bool* status) { initial_metadata_array_.metadata[i].value_length))); } } + grpc_metadata_array_destroy(&initial_metadata_array_); context_->call_ = call_; context_->cq_ = call_cq_; Call call(call_, server_, call_cq_, server_->max_message_size_); -- cgit v1.2.3 From ced73bde96f64b40d0798cb915cc59ae1c240f26 Mon Sep 17 00:00:00 2001 From: Vijay Pai Date: Wed, 17 Jun 2015 10:23:28 -0700 Subject: Split cq creation from request initiation so that cq creation can be removed from C++ lock. --- src/cpp/server/server.cc | 20 +++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-) (limited to 'src/cpp/server') diff --git a/src/cpp/server/server.cc b/src/cpp/server/server.cc index dbd88c5b8c..024537c34a 100644 --- a/src/cpp/server/server.cc +++ b/src/cpp/server/server.cc @@ -71,7 +71,8 @@ class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag { RpcMethod::SERVER_STREAMING), has_response_payload_(method->method_type() == RpcMethod::NORMAL_RPC || method->method_type() == - RpcMethod::CLIENT_STREAMING) { + RpcMethod::CLIENT_STREAMING), + cq_(nullptr) { grpc_metadata_array_init(&request_metadata_); } @@ -90,10 +91,18 @@ class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag { return mrd; } + void SetupRequest() { + cq_ = grpc_completion_queue_create(); + } + + void TeardownRequest() { + grpc_completion_queue_destroy(cq_); + cq_ = nullptr; + } + void Request(grpc_server* server, grpc_completion_queue* notify_cq) { - GPR_ASSERT(!in_flight_); + GPR_ASSERT(cq_ && !in_flight_); in_flight_ = true; - cq_ = grpc_completion_queue_create(); GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_registered_call( server, tag_, &call_, &deadline_, &request_metadata_, @@ -288,6 +297,7 @@ bool Server::Start() { // Start processing rpcs. if (!sync_methods_->empty()) { for (auto m = sync_methods_->begin(); m != sync_methods_->end(); m++) { + m->SetupRequest(); m->Request(server_, cq_.cq()); } @@ -472,9 +482,13 @@ void Server::RunRpc() { if (ok) { SyncRequest::CallData cd(this, mrd); { + mrd->SetupRequest(); grpc::unique_lock lock(mu_); if (!shutdown_) { mrd->Request(server_, cq_.cq()); + } else { + // destroy the structure that was created + mrd->TeardownRequest(); } } cd.Run(); -- cgit v1.2.3 From 026e600b5bb61743cf6ac86623b622520ae2d353 Mon Sep 17 00:00:00 2001 From: Craig Tiller Date: Mon, 22 Jun 2015 11:41:14 -0700 Subject: Update to set flags=0 on all ops --- include/grpc++/impl/call.h | 11 ++++++++++- src/cpp/server/server_context.cc | 1 + 2 files changed, 11 insertions(+), 1 deletion(-) (limited to 'src/cpp/server') diff --git a/include/grpc++/impl/call.h b/include/grpc++/impl/call.h index 2584caec71..33e66816f5 100644 --- a/include/grpc++/impl/call.h +++ b/include/grpc++/impl/call.h @@ -84,6 +84,7 @@ class CallOpSendInitialMetadata { if (!send_) return; grpc_op* op = &ops[(*nops)++]; op->op = GRPC_OP_SEND_INITIAL_METADATA; + op->flags = 0; op->data.send_initial_metadata.count = initial_metadata_count_; op->data.send_initial_metadata.metadata = initial_metadata_; } @@ -110,6 +111,7 @@ class CallOpSendMessage { if (send_buf_ == nullptr) return; grpc_op* op = &ops[(*nops)++]; op->op = GRPC_OP_SEND_MESSAGE; + op->flags = 0; op->data.send_message = send_buf_; } void FinishOp(bool* status, int max_message_size) { @@ -141,6 +143,7 @@ class CallOpRecvMessage { if (message_ == nullptr) return; grpc_op* op = &ops[(*nops)++]; op->op = GRPC_OP_RECV_MESSAGE; + op->flags = 0; op->data.recv_message = &recv_buf_; } @@ -188,6 +191,7 @@ class CallOpGenericRecvMessage { if (!deserialize_) return; grpc_op* op = &ops[(*nops)++]; op->op = GRPC_OP_RECV_MESSAGE; + op->flags = 0; op->data.recv_message = &recv_buf_; } @@ -223,7 +227,9 @@ class CallOpClientSendClose { protected: void AddOp(grpc_op* ops, size_t* nops) { if (!send_) return; - ops[(*nops)++].op = GRPC_OP_SEND_CLOSE_FROM_CLIENT; + grpc_op* op = &ops[(*nops)++]; + op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT; + op->flags = 0; } void FinishOp(bool* status, int max_message_size) { send_ = false; } @@ -256,6 +262,7 @@ class CallOpServerSendStatus { op->data.send_status_from_server.status = send_status_code_; op->data.send_status_from_server.status_details = send_status_details_.empty() ? nullptr : send_status_details_.c_str(); + op->flags = 0; } void FinishOp(bool* status, int max_message_size) { @@ -288,6 +295,7 @@ class CallOpRecvInitialMetadata { grpc_op* op = &ops[(*nops)++]; op->op = GRPC_OP_RECV_INITIAL_METADATA; op->data.recv_initial_metadata = &recv_initial_metadata_arr_; + op->flags = 0; } void FinishOp(bool* status, int max_message_size) { if (recv_initial_metadata_ == nullptr) return; @@ -324,6 +332,7 @@ class CallOpClientRecvStatus { op->data.recv_status_on_client.status_details = &status_details_; op->data.recv_status_on_client.status_details_capacity = &status_details_capacity_; + op->flags = 0; } void FinishOp(bool* status, int max_message_size) { diff --git a/src/cpp/server/server_context.cc b/src/cpp/server/server_context.cc index eea9645e37..699895a3cf 100644 --- a/src/cpp/server/server_context.cc +++ b/src/cpp/server/server_context.cc @@ -79,6 +79,7 @@ bool ServerContext::CompletionOp::CheckCancelled(CompletionQueue* cq) { void ServerContext::CompletionOp::FillOps(grpc_op* ops, size_t* nops) { ops->op = GRPC_OP_RECV_CLOSE_ON_SERVER; ops->data.recv_close_on_server.cancelled = &cancelled_; + ops->flags = 0; *nops = 1; } -- cgit v1.2.3 From 3deb0069f4861451fc174859c293ddafcad648a9 Mon Sep 17 00:00:00 2001 From: yang-g Date: Tue, 23 Jun 2015 14:06:08 -0700 Subject: Only copy stuff when status is ok --- src/cpp/server/server.cc | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) (limited to 'src/cpp/server') diff --git a/src/cpp/server/server.cc b/src/cpp/server/server.cc index 31b6a0ee00..4c44d9ec50 100644 --- a/src/cpp/server/server.cc +++ b/src/cpp/server/server.cc @@ -368,10 +368,12 @@ Server::GenericAsyncRequest::GenericAsyncRequest( bool Server::GenericAsyncRequest::FinalizeResult(void** tag, bool* status) { // TODO(yangg) remove the copy here. - static_cast(context_)->method_ = call_details_.method; - static_cast(context_)->host_ = call_details_.host; - gpr_free(call_details_.method); - gpr_free(call_details_.host); + if (*status) { + static_cast(context_)->method_ = call_details_.method; + static_cast(context_)->host_ = call_details_.host; + gpr_free(call_details_.method); + gpr_free(call_details_.host); + } return BaseAsyncRequest::FinalizeResult(tag, status); } -- cgit v1.2.3 From a58cab30b2e47f1efdad8cd78b820e818ba30fbb Mon Sep 17 00:00:00 2001 From: yang-g Date: Tue, 23 Jun 2015 14:37:15 -0700 Subject: release memory even if the status is false --- src/cpp/server/server.cc | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'src/cpp/server') diff --git a/src/cpp/server/server.cc b/src/cpp/server/server.cc index 4c44d9ec50..f930dbb2b8 100644 --- a/src/cpp/server/server.cc +++ b/src/cpp/server/server.cc @@ -369,11 +369,12 @@ Server::GenericAsyncRequest::GenericAsyncRequest( bool Server::GenericAsyncRequest::FinalizeResult(void** tag, bool* status) { // TODO(yangg) remove the copy here. if (*status) { - static_cast(context_)->method_ = call_details_.method; + static_cast(context_)->method_ = + call_details_.method; static_cast(context_)->host_ = call_details_.host; - gpr_free(call_details_.method); - gpr_free(call_details_.host); } + gpr_free(call_details_.method); + gpr_free(call_details_.host); return BaseAsyncRequest::FinalizeResult(tag, status); } -- cgit v1.2.3 From f75fc12e3a1a614ee2d5d565742764e47d9aef96 Mon Sep 17 00:00:00 2001 From: Craig Tiller Date: Thu, 25 Jun 2015 06:58:00 -0700 Subject: Add a test that headers are properly in build.json Clean up anything that failed --- BUILD | 3 + Makefile | 100 +- build.json | 75 +- src/compiler/python_generator.cc | 2 +- src/core/census/context.c | 2 +- src/cpp/client/channel.cc | 1 - src/cpp/client/channel_arguments.cc | 14 - src/cpp/client/secure_channel_arguments.cc | 54 + src/cpp/server/insecure_server_credentials.cc | 3 +- src/cpp/server/server.cc | 1 - src/cpp/server/server_credentials.cc | 2 - .../run_tests/sources_and_headers.json.template | 27 + test/core/bad_client/gen_build_json.py | 9 + test/core/end2end/gen_build_json.py | 34 +- test/cpp/qps/qps_worker.cc | 2 +- test/cpp/qps/worker.cc | 2 +- tools/doxygen/Doxyfile.c++.internal | 2 +- tools/run_tests/check_sources_and_headers.py | 55 + tools/run_tests/run_tests.py | 3 +- tools/run_tests/sources_and_headers.json | 10585 +++++++++++++++++++ vsprojects/grpc++/grpc++.vcxproj | 2 + vsprojects/grpc++/grpc++.vcxproj.filters | 3 + .../grpc_plugin_support.vcxproj | 2 + vsprojects/grpc_test_util/grpc_test_util.vcxproj | 9 + 24 files changed, 10859 insertions(+), 133 deletions(-) create mode 100644 src/cpp/client/secure_channel_arguments.cc create mode 100644 templates/tools/run_tests/sources_and_headers.json.template create mode 100755 tools/run_tests/check_sources_and_headers.py create mode 100644 tools/run_tests/sources_and_headers.json (limited to 'src/cpp/server') diff --git a/BUILD b/BUILD index d7f0e5a588..fbcfd66400 100644 --- a/BUILD +++ b/BUILD @@ -578,6 +578,7 @@ cc_library( "src/cpp/server/secure_server_credentials.h", "src/cpp/client/channel.h", "src/cpp/server/thread_pool.h", + "src/cpp/client/secure_channel_arguments.cc", "src/cpp/client/secure_credentials.cc", "src/cpp/server/secure_server_credentials.cc", "src/cpp/client/channel.cc", @@ -740,6 +741,8 @@ cc_library( cc_library( name = "grpc_plugin_support", srcs = [ + "include/grpc++/config.h", + "include/grpc++/config_protobuf.h", "src/compiler/config.h", "src/compiler/cpp_generator.h", "src/compiler/cpp_generator_helpers.h", diff --git a/Makefile b/Makefile index 26899c5c05..df6be1d4d2 100644 --- a/Makefile +++ b/Makefile @@ -1261,7 +1261,7 @@ privatelibs: privatelibs_c privatelibs_cxx privatelibs_c: $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util_unsecure.a $(LIBDIR)/$(CONFIG)/libend2end_fixture_chttp2_fake_security.a $(LIBDIR)/$(CONFIG)/libend2end_fixture_chttp2_fullstack.a $(LIBDIR)/$(CONFIG)/libend2end_fixture_chttp2_fullstack_uds_posix.a $(LIBDIR)/$(CONFIG)/libend2end_fixture_chttp2_fullstack_with_poll.a $(LIBDIR)/$(CONFIG)/libend2end_fixture_chttp2_simple_ssl_fullstack.a $(LIBDIR)/$(CONFIG)/libend2end_fixture_chttp2_simple_ssl_fullstack_with_poll.a $(LIBDIR)/$(CONFIG)/libend2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack.a $(LIBDIR)/$(CONFIG)/libend2end_fixture_chttp2_socket_pair.a $(LIBDIR)/$(CONFIG)/libend2end_fixture_chttp2_socket_pair_one_byte_at_a_time.a $(LIBDIR)/$(CONFIG)/libend2end_fixture_chttp2_socket_pair_with_grpc_trace.a $(LIBDIR)/$(CONFIG)/libend2end_test_bad_hostname.a $(LIBDIR)/$(CONFIG)/libend2end_test_cancel_after_accept.a $(LIBDIR)/$(CONFIG)/libend2end_test_cancel_after_accept_and_writes_closed.a $(LIBDIR)/$(CONFIG)/libend2end_test_cancel_after_invoke.a $(LIBDIR)/$(CONFIG)/libend2end_test_cancel_before_invoke.a $(LIBDIR)/$(CONFIG)/libend2end_test_cancel_in_a_vacuum.a $(LIBDIR)/$(CONFIG)/libend2end_test_census_simple_request.a $(LIBDIR)/$(CONFIG)/libend2end_test_disappearing_server.a $(LIBDIR)/$(CONFIG)/libend2end_test_early_server_shutdown_finishes_inflight_calls.a $(LIBDIR)/$(CONFIG)/libend2end_test_early_server_shutdown_finishes_tags.a $(LIBDIR)/$(CONFIG)/libend2end_test_empty_batch.a $(LIBDIR)/$(CONFIG)/libend2end_test_graceful_server_shutdown.a $(LIBDIR)/$(CONFIG)/libend2end_test_invoke_large_request.a $(LIBDIR)/$(CONFIG)/libend2end_test_max_concurrent_streams.a $(LIBDIR)/$(CONFIG)/libend2end_test_max_message_length.a $(LIBDIR)/$(CONFIG)/libend2end_test_no_op.a $(LIBDIR)/$(CONFIG)/libend2end_test_ping_pong_streaming.a $(LIBDIR)/$(CONFIG)/libend2end_test_registered_call.a $(LIBDIR)/$(CONFIG)/libend2end_test_request_response_with_binary_metadata_and_payload.a $(LIBDIR)/$(CONFIG)/libend2end_test_request_response_with_metadata_and_payload.a $(LIBDIR)/$(CONFIG)/libend2end_test_request_response_with_payload.a $(LIBDIR)/$(CONFIG)/libend2end_test_request_response_with_payload_and_call_creds.a $(LIBDIR)/$(CONFIG)/libend2end_test_request_response_with_trailing_metadata_and_payload.a $(LIBDIR)/$(CONFIG)/libend2end_test_request_with_flags.a $(LIBDIR)/$(CONFIG)/libend2end_test_request_with_large_metadata.a $(LIBDIR)/$(CONFIG)/libend2end_test_request_with_payload.a $(LIBDIR)/$(CONFIG)/libend2end_test_server_finishes_request.a $(LIBDIR)/$(CONFIG)/libend2end_test_simple_delayed_request.a $(LIBDIR)/$(CONFIG)/libend2end_test_simple_request.a $(LIBDIR)/$(CONFIG)/libend2end_test_simple_request_with_high_initial_sequence_number.a $(LIBDIR)/$(CONFIG)/libend2end_certs.a $(LIBDIR)/$(CONFIG)/libbad_client_test.a -privatelibs_cxx: $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libinterop_client_helper.a $(LIBDIR)/$(CONFIG)/libinterop_client_main.a $(LIBDIR)/$(CONFIG)/libinterop_server_helper.a $(LIBDIR)/$(CONFIG)/libinterop_server_main.a $(LIBDIR)/$(CONFIG)/libqps.a +privatelibs_cxx: $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libinterop_client_helper.a $(LIBDIR)/$(CONFIG)/libinterop_client_main.a $(LIBDIR)/$(CONFIG)/libinterop_server_helper.a $(LIBDIR)/$(CONFIG)/libinterop_server_main.a $(LIBDIR)/$(CONFIG)/libqps.a buildtests: buildtests_c buildtests_cxx @@ -3397,6 +3397,7 @@ endif LIBGRPC++_SRC = \ + src/cpp/client/secure_channel_arguments.cc \ src/cpp/client/secure_credentials.cc \ src/cpp/server/secure_server_credentials.cc \ src/cpp/client/channel.cc \ @@ -3533,57 +3534,6 @@ endif endif -LIBGRPC++_BENCHMARK_CONFIG_SRC = \ - $(GENDIR)/test/cpp/qps/qpstest.pb.cc $(GENDIR)/test/cpp/qps/qpstest.grpc.pb.cc \ - test/cpp/qps/report.cc \ - test/cpp/util/benchmark_config.cc \ - - -LIBGRPC++_BENCHMARK_CONFIG_OBJS = $(addprefix $(OBJDIR)/$(CONFIG)/, $(addsuffix .o, $(basename $(LIBGRPC++_BENCHMARK_CONFIG_SRC)))) - -ifeq ($(NO_SECURE),true) - -# You can't build secure libraries if you don't have OpenSSL with ALPN. - -$(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a: openssl_dep_error - - -else - -ifeq ($(NO_PROTOBUF),true) - -# You can't build a C++ library if you don't have protobuf - a bit overreached, but still okay. - -$(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a: protobuf_dep_error - - -else - -$(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a: $(ZLIB_DEP) $(OPENSSL_DEP) $(PROTOBUF_DEP) $(LIBGRPC++_BENCHMARK_CONFIG_OBJS) - $(E) "[AR] Creating $@" - $(Q) mkdir -p `dirname $@` - $(Q) rm -f $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a - $(Q) $(AR) rcs $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LIBGRPC++_BENCHMARK_CONFIG_OBJS) -ifeq ($(SYSTEM),Darwin) - $(Q) ranlib $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a -endif - - - - -endif - -endif - -ifneq ($(NO_SECURE),true) -ifneq ($(NO_DEPS),true) --include $(LIBGRPC++_BENCHMARK_CONFIG_OBJS:.o=.dep) -endif -endif -$(OBJDIR)/$(CONFIG)/test/cpp/qps/report.o: $(GENDIR)/test/cpp/qps/qpstest.pb.cc $(GENDIR)/test/cpp/qps/qpstest.grpc.pb.cc -$(OBJDIR)/$(CONFIG)/test/cpp/util/benchmark_config.o: $(GENDIR)/test/cpp/qps/qpstest.pb.cc $(GENDIR)/test/cpp/qps/qpstest.grpc.pb.cc - - LIBGRPC++_TEST_CONFIG_SRC = \ test/cpp/util/test_config.cc \ @@ -4100,9 +4050,11 @@ LIBQPS_SRC = \ test/cpp/qps/client_sync.cc \ test/cpp/qps/driver.cc \ test/cpp/qps/qps_worker.cc \ + test/cpp/qps/report.cc \ test/cpp/qps/server_async.cc \ test/cpp/qps/server_sync.cc \ test/cpp/qps/timer.cc \ + test/cpp/util/benchmark_config.cc \ LIBQPS_OBJS = $(addprefix $(OBJDIR)/$(CONFIG)/, $(addsuffix .o, $(basename $(LIBQPS_SRC)))) @@ -4150,9 +4102,11 @@ $(OBJDIR)/$(CONFIG)/test/cpp/qps/client_async.o: $(GENDIR)/test/cpp/qps/qpstest. $(OBJDIR)/$(CONFIG)/test/cpp/qps/client_sync.o: $(GENDIR)/test/cpp/qps/qpstest.pb.cc $(GENDIR)/test/cpp/qps/qpstest.grpc.pb.cc $(OBJDIR)/$(CONFIG)/test/cpp/qps/driver.o: $(GENDIR)/test/cpp/qps/qpstest.pb.cc $(GENDIR)/test/cpp/qps/qpstest.grpc.pb.cc $(OBJDIR)/$(CONFIG)/test/cpp/qps/qps_worker.o: $(GENDIR)/test/cpp/qps/qpstest.pb.cc $(GENDIR)/test/cpp/qps/qpstest.grpc.pb.cc +$(OBJDIR)/$(CONFIG)/test/cpp/qps/report.o: $(GENDIR)/test/cpp/qps/qpstest.pb.cc $(GENDIR)/test/cpp/qps/qpstest.grpc.pb.cc $(OBJDIR)/$(CONFIG)/test/cpp/qps/server_async.o: $(GENDIR)/test/cpp/qps/qpstest.pb.cc $(GENDIR)/test/cpp/qps/qpstest.grpc.pb.cc $(OBJDIR)/$(CONFIG)/test/cpp/qps/server_sync.o: $(GENDIR)/test/cpp/qps/qpstest.pb.cc $(GENDIR)/test/cpp/qps/qpstest.grpc.pb.cc $(OBJDIR)/$(CONFIG)/test/cpp/qps/timer.o: $(GENDIR)/test/cpp/qps/qpstest.pb.cc $(GENDIR)/test/cpp/qps/qpstest.grpc.pb.cc +$(OBJDIR)/$(CONFIG)/test/cpp/util/benchmark_config.o: $(GENDIR)/test/cpp/qps/qpstest.pb.cc $(GENDIR)/test/cpp/qps/qpstest.grpc.pb.cc LIBGRPC_CSHARP_EXT_SRC = \ @@ -7346,16 +7300,16 @@ $(BINDIR)/$(CONFIG)/async_streaming_ping_pong_test: protobuf_dep_error else -$(BINDIR)/$(CONFIG)/async_streaming_ping_pong_test: $(PROTOBUF_DEP) $(ASYNC_STREAMING_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a +$(BINDIR)/$(CONFIG)/async_streaming_ping_pong_test: $(PROTOBUF_DEP) $(ASYNC_STREAMING_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(E) "[LD] Linking $@" $(Q) mkdir -p `dirname $@` - $(Q) $(LDXX) $(LDFLAGS) $(ASYNC_STREAMING_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LDLIBSXX) $(LDLIBS_PROTOBUF) $(LDLIBS) $(LDLIBS_SECURE) $(GTEST_LIB) -o $(BINDIR)/$(CONFIG)/async_streaming_ping_pong_test + $(Q) $(LDXX) $(LDFLAGS) $(ASYNC_STREAMING_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LDLIBSXX) $(LDLIBS_PROTOBUF) $(LDLIBS) $(LDLIBS_SECURE) $(GTEST_LIB) -o $(BINDIR)/$(CONFIG)/async_streaming_ping_pong_test endif endif -$(OBJDIR)/$(CONFIG)/test/cpp/qps/async_streaming_ping_pong_test.o: $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a +$(OBJDIR)/$(CONFIG)/test/cpp/qps/async_streaming_ping_pong_test.o: $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a deps_async_streaming_ping_pong_test: $(ASYNC_STREAMING_PING_PONG_TEST_OBJS:.o=.dep) ifneq ($(NO_SECURE),true) @@ -7386,16 +7340,16 @@ $(BINDIR)/$(CONFIG)/async_unary_ping_pong_test: protobuf_dep_error else -$(BINDIR)/$(CONFIG)/async_unary_ping_pong_test: $(PROTOBUF_DEP) $(ASYNC_UNARY_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a +$(BINDIR)/$(CONFIG)/async_unary_ping_pong_test: $(PROTOBUF_DEP) $(ASYNC_UNARY_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(E) "[LD] Linking $@" $(Q) mkdir -p `dirname $@` - $(Q) $(LDXX) $(LDFLAGS) $(ASYNC_UNARY_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LDLIBSXX) $(LDLIBS_PROTOBUF) $(LDLIBS) $(LDLIBS_SECURE) $(GTEST_LIB) -o $(BINDIR)/$(CONFIG)/async_unary_ping_pong_test + $(Q) $(LDXX) $(LDFLAGS) $(ASYNC_UNARY_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LDLIBSXX) $(LDLIBS_PROTOBUF) $(LDLIBS) $(LDLIBS_SECURE) $(GTEST_LIB) -o $(BINDIR)/$(CONFIG)/async_unary_ping_pong_test endif endif -$(OBJDIR)/$(CONFIG)/test/cpp/qps/async_unary_ping_pong_test.o: $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a +$(OBJDIR)/$(CONFIG)/test/cpp/qps/async_unary_ping_pong_test.o: $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a deps_async_unary_ping_pong_test: $(ASYNC_UNARY_PING_PONG_TEST_OBJS:.o=.dep) ifneq ($(NO_SECURE),true) @@ -8264,16 +8218,16 @@ $(BINDIR)/$(CONFIG)/qps_driver: protobuf_dep_error else -$(BINDIR)/$(CONFIG)/qps_driver: $(PROTOBUF_DEP) $(QPS_DRIVER_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a +$(BINDIR)/$(CONFIG)/qps_driver: $(PROTOBUF_DEP) $(QPS_DRIVER_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a $(E) "[LD] Linking $@" $(Q) mkdir -p `dirname $@` - $(Q) $(LDXX) $(LDFLAGS) $(QPS_DRIVER_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LDLIBSXX) $(LDLIBS_PROTOBUF) $(LDLIBS) $(LDLIBS_SECURE) $(GTEST_LIB) -o $(BINDIR)/$(CONFIG)/qps_driver + $(Q) $(LDXX) $(LDFLAGS) $(QPS_DRIVER_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a $(LDLIBSXX) $(LDLIBS_PROTOBUF) $(LDLIBS) $(LDLIBS_SECURE) $(GTEST_LIB) -o $(BINDIR)/$(CONFIG)/qps_driver endif endif -$(OBJDIR)/$(CONFIG)/test/cpp/qps/qps_driver.o: $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a +$(OBJDIR)/$(CONFIG)/test/cpp/qps/qps_driver.o: $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a deps_qps_driver: $(QPS_DRIVER_OBJS:.o=.dep) ifneq ($(NO_SECURE),true) @@ -8344,16 +8298,16 @@ $(BINDIR)/$(CONFIG)/qps_test: protobuf_dep_error else -$(BINDIR)/$(CONFIG)/qps_test: $(PROTOBUF_DEP) $(QPS_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a +$(BINDIR)/$(CONFIG)/qps_test: $(PROTOBUF_DEP) $(QPS_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a $(E) "[LD] Linking $@" $(Q) mkdir -p `dirname $@` - $(Q) $(LDXX) $(LDFLAGS) $(QPS_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a $(LDLIBSXX) $(LDLIBS_PROTOBUF) $(LDLIBS) $(LDLIBS_SECURE) $(GTEST_LIB) -o $(BINDIR)/$(CONFIG)/qps_test + $(Q) $(LDXX) $(LDFLAGS) $(QPS_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a $(LDLIBSXX) $(LDLIBS_PROTOBUF) $(LDLIBS) $(LDLIBS_SECURE) $(GTEST_LIB) -o $(BINDIR)/$(CONFIG)/qps_test endif endif -$(OBJDIR)/$(CONFIG)/test/cpp/qps/qps_test.o: $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a +$(OBJDIR)/$(CONFIG)/test/cpp/qps/qps_test.o: $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a deps_qps_test: $(QPS_TEST_OBJS:.o=.dep) ifneq ($(NO_SECURE),true) @@ -8384,16 +8338,16 @@ $(BINDIR)/$(CONFIG)/qps_test_openloop: protobuf_dep_error else -$(BINDIR)/$(CONFIG)/qps_test_openloop: $(PROTOBUF_DEP) $(QPS_TEST_OPENLOOP_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a +$(BINDIR)/$(CONFIG)/qps_test_openloop: $(PROTOBUF_DEP) $(QPS_TEST_OPENLOOP_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a $(E) "[LD] Linking $@" $(Q) mkdir -p `dirname $@` - $(Q) $(LDXX) $(LDFLAGS) $(QPS_TEST_OPENLOOP_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a $(LDLIBSXX) $(LDLIBS_PROTOBUF) $(LDLIBS) $(LDLIBS_SECURE) $(GTEST_LIB) -o $(BINDIR)/$(CONFIG)/qps_test_openloop + $(Q) $(LDXX) $(LDFLAGS) $(QPS_TEST_OPENLOOP_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a $(LDLIBSXX) $(LDLIBS_PROTOBUF) $(LDLIBS) $(LDLIBS_SECURE) $(GTEST_LIB) -o $(BINDIR)/$(CONFIG)/qps_test_openloop endif endif -$(OBJDIR)/$(CONFIG)/test/cpp/qps/qps_test_openloop.o: $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a +$(OBJDIR)/$(CONFIG)/test/cpp/qps/qps_test_openloop.o: $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_config.a deps_qps_test_openloop: $(QPS_TEST_OPENLOOP_OBJS:.o=.dep) ifneq ($(NO_SECURE),true) @@ -8584,16 +8538,16 @@ $(BINDIR)/$(CONFIG)/sync_streaming_ping_pong_test: protobuf_dep_error else -$(BINDIR)/$(CONFIG)/sync_streaming_ping_pong_test: $(PROTOBUF_DEP) $(SYNC_STREAMING_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a +$(BINDIR)/$(CONFIG)/sync_streaming_ping_pong_test: $(PROTOBUF_DEP) $(SYNC_STREAMING_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(E) "[LD] Linking $@" $(Q) mkdir -p `dirname $@` - $(Q) $(LDXX) $(LDFLAGS) $(SYNC_STREAMING_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LDLIBSXX) $(LDLIBS_PROTOBUF) $(LDLIBS) $(LDLIBS_SECURE) $(GTEST_LIB) -o $(BINDIR)/$(CONFIG)/sync_streaming_ping_pong_test + $(Q) $(LDXX) $(LDFLAGS) $(SYNC_STREAMING_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LDLIBSXX) $(LDLIBS_PROTOBUF) $(LDLIBS) $(LDLIBS_SECURE) $(GTEST_LIB) -o $(BINDIR)/$(CONFIG)/sync_streaming_ping_pong_test endif endif -$(OBJDIR)/$(CONFIG)/test/cpp/qps/sync_streaming_ping_pong_test.o: $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a +$(OBJDIR)/$(CONFIG)/test/cpp/qps/sync_streaming_ping_pong_test.o: $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a deps_sync_streaming_ping_pong_test: $(SYNC_STREAMING_PING_PONG_TEST_OBJS:.o=.dep) ifneq ($(NO_SECURE),true) @@ -8624,16 +8578,16 @@ $(BINDIR)/$(CONFIG)/sync_unary_ping_pong_test: protobuf_dep_error else -$(BINDIR)/$(CONFIG)/sync_unary_ping_pong_test: $(PROTOBUF_DEP) $(SYNC_UNARY_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a +$(BINDIR)/$(CONFIG)/sync_unary_ping_pong_test: $(PROTOBUF_DEP) $(SYNC_UNARY_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(E) "[LD] Linking $@" $(Q) mkdir -p `dirname $@` - $(Q) $(LDXX) $(LDFLAGS) $(SYNC_UNARY_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LDLIBSXX) $(LDLIBS_PROTOBUF) $(LDLIBS) $(LDLIBS_SECURE) $(GTEST_LIB) -o $(BINDIR)/$(CONFIG)/sync_unary_ping_pong_test + $(Q) $(LDXX) $(LDFLAGS) $(SYNC_UNARY_PING_PONG_TEST_OBJS) $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a $(LDLIBSXX) $(LDLIBS_PROTOBUF) $(LDLIBS) $(LDLIBS_SECURE) $(GTEST_LIB) -o $(BINDIR)/$(CONFIG)/sync_unary_ping_pong_test endif endif -$(OBJDIR)/$(CONFIG)/test/cpp/qps/sync_unary_ping_pong_test.o: $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++_benchmark_config.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a +$(OBJDIR)/$(CONFIG)/test/cpp/qps/sync_unary_ping_pong_test.o: $(LIBDIR)/$(CONFIG)/libqps.a $(LIBDIR)/$(CONFIG)/libgrpc++_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc_test_util.a $(LIBDIR)/$(CONFIG)/libgrpc++.a $(LIBDIR)/$(CONFIG)/libgrpc.a $(LIBDIR)/$(CONFIG)/libgpr_test_util.a $(LIBDIR)/$(CONFIG)/libgpr.a deps_sync_unary_ping_pong_test: $(SYNC_UNARY_PING_PONG_TEST_OBJS:.o=.dep) ifneq ($(NO_SECURE),true) diff --git a/build.json b/build.json index e01a419bbe..282e82562a 100644 --- a/build.json +++ b/build.json @@ -289,6 +289,14 @@ }, { "name": "grpc_test_util_base", + "headers": [ + "test/core/end2end/cq_verifier.h", + "test/core/iomgr/endpoint_tests.h", + "test/core/util/grpc_profiler.h", + "test/core/util/parse_hexstring.h", + "test/core/util/port.h", + "test/core/util/slice_splitter.h" + ], "src": [ "test/core/end2end/cq_verifier.c", "test/core/iomgr/endpoint_tests.c", @@ -466,6 +474,9 @@ "name": "grpc_test_util", "build": "private", "language": "c", + "headers": [ + "test/core/end2end/data/ssl_test_data.h" + ], "src": [ "test/core/end2end/data/server1_cert.c", "test/core/end2end/data/server1_key.c", @@ -523,6 +534,7 @@ "src/cpp/server/secure_server_credentials.h" ], "src": [ + "src/cpp/client/secure_channel_arguments.cc", "src/cpp/client/secure_credentials.cc", "src/cpp/server/secure_server_credentials.cc" ], @@ -537,20 +549,13 @@ "secure": "check", "vs_project_guid": "{C187A093-A0FE-489D-A40A-6E33DE0F9FEB}" }, - { - "name": "grpc++_benchmark_config", - "build": "private", - "language": "c++", - "src": [ - "test/cpp/qps/qpstest.proto", - "test/cpp/qps/report.cc", - "test/cpp/util/benchmark_config.cc" - ] - }, { "name": "grpc++_test_config", "build": "private", "language": "c++", + "headers": [ + "test/cpp/util/test_config.h" + ], "src": [ "test/cpp/util/test_config.cc" ] @@ -559,6 +564,12 @@ "name": "grpc++_test_util", "build": "private", "language": "c++", + "headers": [ + "test/cpp/util/cli_call.h", + "test/cpp/util/create_test_channel.h", + "test/cpp/util/fake_credentials.h", + "test/cpp/util/subprocess.h" + ], "src": [ "test/cpp/util/messages.proto", "test/cpp/util/echo.proto", @@ -567,6 +578,10 @@ "test/cpp/util/create_test_channel.cc", "test/cpp/util/fake_credentials.cc", "test/cpp/util/subprocess.cc" + ], + "deps": [ + "grpc++", + "grpc_test_util" ] }, { @@ -589,6 +604,8 @@ "build": "protoc", "language": "c++", "headers": [ + "include/grpc++/config.h", + "include/grpc++/config_protobuf.h", "src/compiler/config.h", "src/compiler/cpp_generator.h", "src/compiler/cpp_generator_helpers.h", @@ -618,6 +635,9 @@ "name": "interop_client_helper", "build": "private", "language": "c++", + "headers": [ + "test/cpp/interop/client_helper.h" + ], "src": [ "test/cpp/interop/client_helper.cc" ], @@ -633,6 +653,9 @@ "name": "interop_client_main", "build": "private", "language": "c++", + "headers": [ + "test/cpp/interop/interop_client.h" + ], "src": [ "test/proto/empty.proto", "test/proto/messages.proto", @@ -641,6 +664,7 @@ "test/cpp/interop/interop_client.cc" ], "deps": [ + "interop_client_helper", "grpc++_test_util", "grpc_test_util", "grpc++", @@ -654,6 +678,9 @@ "name": "interop_server_helper", "build": "private", "language": "c++", + "headers": [ + "test/cpp/interop/server_helper.h" + ], "src": [ "test/cpp/interop/server_helper.cc" ], @@ -675,6 +702,7 @@ "test/cpp/interop/server.cc" ], "deps": [ + "interop_server_helper", "grpc++_test_util", "grpc_test_util", "grpc++", @@ -688,6 +716,10 @@ "name": "pubsub_client_lib", "build": "do_not_build", "language": "c++", + "headers": [ + "examples/pubsub/publisher.h", + "examples/pubsub/subscriber.h" + ], "src": [ "examples/pubsub/label.proto", "examples/pubsub/empty.proto", @@ -706,11 +738,16 @@ "build": "private", "language": "c++", "headers": [ + "test/cpp/qps/client.h", "test/cpp/qps/driver.h", + "test/cpp/qps/histogram.h", "test/cpp/qps/interarrival.h", "test/cpp/qps/qps_worker.h", "test/cpp/qps/report.h", - "test/cpp/qps/timer.h" + "test/cpp/qps/server.h", + "test/cpp/qps/stats.h", + "test/cpp/qps/timer.h", + "test/cpp/util/benchmark_config.h" ], "src": [ "test/cpp/qps/qpstest.proto", @@ -718,13 +755,16 @@ "test/cpp/qps/client_sync.cc", "test/cpp/qps/driver.cc", "test/cpp/qps/qps_worker.cc", + "test/cpp/qps/report.cc", "test/cpp/qps/server_async.cc", "test/cpp/qps/server_sync.cc", - "test/cpp/qps/timer.cc" + "test/cpp/qps/timer.cc", + "test/cpp/util/benchmark_config.cc" ], "deps": [ "grpc_test_util", - "grpc++_test_util" + "grpc++_test_util", + "grpc++" ] }, { @@ -1729,7 +1769,6 @@ "deps": [ "qps", "grpc++_test_util", - "grpc++_benchmark_config", "grpc_test_util", "grpc++", "grpc", @@ -1747,7 +1786,6 @@ "deps": [ "qps", "grpc++_test_util", - "grpc++_benchmark_config", "grpc_test_util", "grpc++", "grpc", @@ -2123,8 +2161,7 @@ "grpc", "gpr_test_util", "gpr", - "grpc++_test_config", - "grpc++_benchmark_config" + "grpc++_test_config" ] }, { @@ -2155,7 +2192,6 @@ "deps": [ "qps", "grpc++_test_util", - "grpc++_benchmark_config", "grpc_test_util", "grpc++", "grpc", @@ -2174,7 +2210,6 @@ "deps": [ "qps", "grpc++_test_util", - "grpc++_benchmark_config", "grpc_test_util", "grpc++", "grpc", @@ -2263,7 +2298,6 @@ "deps": [ "qps", "grpc++_test_util", - "grpc++_benchmark_config", "grpc_test_util", "grpc++", "grpc", @@ -2281,7 +2315,6 @@ "deps": [ "qps", "grpc++_test_util", - "grpc++_benchmark_config", "grpc_test_util", "grpc++", "grpc", diff --git a/src/compiler/python_generator.cc b/src/compiler/python_generator.cc index 72149bc4e3..724b69c703 100644 --- a/src/compiler/python_generator.cc +++ b/src/compiler/python_generator.cc @@ -42,7 +42,7 @@ #include #include -#include "grpc++/config.h" +#include #include "src/compiler/config.h" #include "src/compiler/generator_helpers.h" #include "src/compiler/python_generator.h" diff --git a/src/core/census/context.c b/src/core/census/context.c index 1358c5127b..df238ec98c 100644 --- a/src/core/census/context.c +++ b/src/core/census/context.c @@ -31,7 +31,7 @@ * */ -#include "context.h" +#include "src/core/census/context.h" #include #include diff --git a/src/cpp/client/channel.cc b/src/cpp/client/channel.cc index 6e6278cb05..72593f877e 100644 --- a/src/cpp/client/channel.cc +++ b/src/cpp/client/channel.cc @@ -36,7 +36,6 @@ #include #include -#include #include #include diff --git a/src/cpp/client/channel_arguments.cc b/src/cpp/client/channel_arguments.cc index 679c4f1503..b271650673 100644 --- a/src/cpp/client/channel_arguments.cc +++ b/src/cpp/client/channel_arguments.cc @@ -33,28 +33,14 @@ #include -#include #include "src/core/channel/channel_args.h" namespace grpc { -void ChannelArguments::SetSslTargetNameOverride(const grpc::string& name) { - SetString(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG, name); -} - void ChannelArguments::SetCompressionLevel(grpc_compression_level level) { SetInt(GRPC_COMPRESSION_LEVEL_ARG, level); } -grpc::string ChannelArguments::GetSslTargetNameOverride() const { - for (unsigned int i = 0; i < args_.size(); i++) { - if (grpc::string(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG) == args_[i].key) { - return args_[i].value.string; - } - } - return ""; -} - void ChannelArguments::SetInt(const grpc::string& key, int value) { grpc_arg arg; arg.type = GRPC_ARG_INTEGER; diff --git a/src/cpp/client/secure_channel_arguments.cc b/src/cpp/client/secure_channel_arguments.cc new file mode 100644 index 0000000000..d89df999ad --- /dev/null +++ b/src/cpp/client/secure_channel_arguments.cc @@ -0,0 +1,54 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include +#include + +#include "src/core/channel/channel_args.h" + +namespace grpc { + +void ChannelArguments::SetSslTargetNameOverride(const grpc::string& name) { + SetString(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG, name); +} + +grpc::string ChannelArguments::GetSslTargetNameOverride() const { + for (unsigned int i = 0; i < args_.size(); i++) { + if (grpc::string(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG) == args_[i].key) { + return args_[i].value.string; + } + } + return ""; +} + +} // namespace grpc diff --git a/src/cpp/server/insecure_server_credentials.cc b/src/cpp/server/insecure_server_credentials.cc index 55dd90d7a7..aca3568e59 100644 --- a/src/cpp/server/insecure_server_credentials.cc +++ b/src/cpp/server/insecure_server_credentials.cc @@ -31,9 +31,10 @@ * */ -#include #include +#include + namespace grpc { namespace { class InsecureServerCredentialsImpl GRPC_FINAL : public ServerCredentials { diff --git a/src/cpp/server/server.cc b/src/cpp/server/server.cc index f930dbb2b8..1437b2dea7 100644 --- a/src/cpp/server/server.cc +++ b/src/cpp/server/server.cc @@ -35,7 +35,6 @@ #include #include -#include #include #include #include diff --git a/src/cpp/server/server_credentials.cc b/src/cpp/server/server_credentials.cc index 6bdb465baa..be3a7425e0 100644 --- a/src/cpp/server/server_credentials.cc +++ b/src/cpp/server/server_credentials.cc @@ -31,8 +31,6 @@ * */ -#include - #include namespace grpc { diff --git a/templates/tools/run_tests/sources_and_headers.json.template b/templates/tools/run_tests/sources_and_headers.json.template new file mode 100644 index 0000000000..01918d0a3d --- /dev/null +++ b/templates/tools/run_tests/sources_and_headers.json.template @@ -0,0 +1,27 @@ +<%! +import json +import os + +def proto_headers(src): + out = [] + for f in src: + name, ext = os.path.splitext(f) + if ext == '.proto': + out.extend(fmt % name for fmt in ['%s.grpc.pb.h', '%s.pb.h']) + return out + +def no_protos(src): + out = [] + for f in src: + if os.path.splitext(f)[1] != '.proto': + out.append(f) + return out +%> + +${json.dumps([{"name": tgt.name, + "language": tgt.language, + "src": no_protos(tgt.src) + tgt.get('public_headers', []) + tgt.get('headers', []), + "headers": tgt.get('public_headers', []) + tgt.get('headers', []) + proto_headers(tgt.src), + "deps": tgt.get('deps', [])} + for tgt in (targets + libs)], + sort_keys=True, indent=2)} diff --git a/test/core/bad_client/gen_build_json.py b/test/core/bad_client/gen_build_json.py index a6fa266bec..33bf65ac04 100755 --- a/test/core/bad_client/gen_build_json.py +++ b/test/core/bad_client/gen_build_json.py @@ -54,6 +54,15 @@ def main(): 'language': 'c', 'src': [ 'test/core/bad_client/bad_client.c' + ], + 'headers': [ + 'test/core/bad_client/bad_client.h' + ], + 'deps': [ + 'grpc_test_util_unsecure', + 'grpc_unsecure', + 'gpr_test_util', + 'gpr' ] }], 'targets': [ diff --git a/test/core/end2end/gen_build_json.py b/test/core/end2end/gen_build_json.py index f47c92bc47..f1c7e85e08 100755 --- a/test/core/end2end/gen_build_json.py +++ b/test/core/end2end/gen_build_json.py @@ -93,6 +93,19 @@ END2END_TESTS = { def main(): + sec_deps = [ + 'end2end_certs', + 'grpc_test_util', + 'grpc', + 'gpr_test_util', + 'gpr' + ] + unsec_deps = [ + 'grpc_test_util_unsecure', + 'grpc_unsecure', + 'gpr_test_util', + 'gpr' + ] json = { '#': 'generated with test/end2end/gen_build_json.py', 'libs': [ @@ -103,6 +116,8 @@ def main(): 'secure': 'check' if END2END_FIXTURES[f].secure else 'no', 'src': ['test/core/end2end/fixtures/%s.c' % f], 'platforms': [ 'posix' ] if f.endswith('_posix') else END2END_FIXTURES[f].platforms, + 'deps': sec_deps if END2END_FIXTURES[f].secure else unsec_deps, + 'headers': ['test/core/end2end/end2end_tests.h'], } for f in sorted(END2END_FIXTURES.keys())] + [ { @@ -111,7 +126,9 @@ def main(): 'language': 'c', 'secure': 'check' if END2END_TESTS[t].secure else 'no', 'src': ['test/core/end2end/tests/%s.c' % t], - 'headers': ['test/core/end2end/tests/cancel_test_helpers.h'] + 'headers': ['test/core/end2end/tests/cancel_test_helpers.h', + 'test/core/end2end/end2end_tests.h'], + 'deps': sec_deps if END2END_TESTS[t].secure else unsec_deps } for t in sorted(END2END_TESTS.keys())] + [ { @@ -135,13 +152,7 @@ def main(): 'platforms': END2END_FIXTURES[f].platforms, 'deps': [ 'end2end_fixture_%s' % f, - 'end2end_test_%s' % t, - 'end2end_certs', - 'grpc_test_util', - 'grpc', - 'gpr_test_util', - 'gpr' - ] + 'end2end_test_%s' % t] + sec_deps } for f in sorted(END2END_FIXTURES.keys()) for t in sorted(END2END_TESTS.keys())] + [ @@ -155,12 +166,7 @@ def main(): 'platforms': END2END_FIXTURES[f].platforms, 'deps': [ 'end2end_fixture_%s' % f, - 'end2end_test_%s' % t, - 'grpc_test_util_unsecure', - 'grpc_unsecure', - 'gpr_test_util', - 'gpr' - ] + 'end2end_test_%s' % t] + unsec_deps } for f in sorted(END2END_FIXTURES.keys()) if not END2END_FIXTURES[f].secure for t in sorted(END2END_TESTS.keys()) if not END2END_TESTS[t].secure]} diff --git a/test/cpp/qps/qps_worker.cc b/test/cpp/qps/qps_worker.cc index 423275ee85..f1cea5ee66 100644 --- a/test/cpp/qps/qps_worker.cc +++ b/test/cpp/qps/qps_worker.cc @@ -31,7 +31,7 @@ * */ -#include "qps_worker.h" +#include "test/cpp/qps/qps_worker.h" #include #include diff --git a/test/cpp/qps/worker.cc b/test/cpp/qps/worker.cc index dfc102fc17..14a8b0b089 100644 --- a/test/cpp/qps/worker.cc +++ b/test/cpp/qps/worker.cc @@ -40,7 +40,7 @@ #include #include -#include "qps_worker.h" +#include "test/cpp/qps/qps_worker.h" #include "test/cpp/util/test_config.h" DEFINE_int32(driver_port, 0, "Driver server port."); diff --git a/tools/doxygen/Doxyfile.c++.internal b/tools/doxygen/Doxyfile.c++.internal index a19f89ac7b..deee6837a0 100644 --- a/tools/doxygen/Doxyfile.c++.internal +++ b/tools/doxygen/Doxyfile.c++.internal @@ -760,7 +760,7 @@ WARN_LOGFILE = # spaces. # Note: If this tag is empty the current directory is searched. -INPUT = include/grpc++/async_generic_service.h include/grpc++/async_unary_call.h include/grpc++/byte_buffer.h include/grpc++/channel_arguments.h include/grpc++/channel_interface.h include/grpc++/client_context.h include/grpc++/completion_queue.h include/grpc++/config.h include/grpc++/config_protobuf.h include/grpc++/create_channel.h include/grpc++/credentials.h include/grpc++/generic_stub.h include/grpc++/impl/call.h include/grpc++/impl/client_unary_call.h include/grpc++/impl/grpc_library.h include/grpc++/impl/internal_stub.h include/grpc++/impl/proto_utils.h include/grpc++/impl/rpc_method.h include/grpc++/impl/rpc_service_method.h include/grpc++/impl/serialization_traits.h include/grpc++/impl/service_type.h include/grpc++/impl/sync.h include/grpc++/impl/sync_cxx11.h include/grpc++/impl/sync_no_cxx11.h include/grpc++/impl/thd.h include/grpc++/impl/thd_cxx11.h include/grpc++/impl/thd_no_cxx11.h include/grpc++/server.h include/grpc++/server_builder.h include/grpc++/server_context.h include/grpc++/server_credentials.h include/grpc++/slice.h include/grpc++/status.h include/grpc++/status_code_enum.h include/grpc++/stream.h include/grpc++/thread_pool_interface.h include/grpc++/time.h src/cpp/client/secure_credentials.h src/cpp/server/secure_server_credentials.h src/cpp/client/channel.h src/cpp/server/thread_pool.h src/cpp/client/secure_credentials.cc src/cpp/server/secure_server_credentials.cc src/cpp/client/channel.cc src/cpp/client/channel_arguments.cc src/cpp/client/client_context.cc src/cpp/client/create_channel.cc src/cpp/client/credentials.cc src/cpp/client/generic_stub.cc src/cpp/client/insecure_credentials.cc src/cpp/client/internal_stub.cc src/cpp/common/call.cc src/cpp/common/completion_queue.cc src/cpp/common/rpc_method.cc src/cpp/proto/proto_utils.cc src/cpp/server/async_generic_service.cc src/cpp/server/create_default_thread_pool.cc src/cpp/server/insecure_server_credentials.cc src/cpp/server/server.cc src/cpp/server/server_builder.cc src/cpp/server/server_context.cc src/cpp/server/server_credentials.cc src/cpp/server/thread_pool.cc src/cpp/util/byte_buffer.cc src/cpp/util/slice.cc src/cpp/util/status.cc src/cpp/util/time.cc +INPUT = include/grpc++/async_generic_service.h include/grpc++/async_unary_call.h include/grpc++/byte_buffer.h include/grpc++/channel_arguments.h include/grpc++/channel_interface.h include/grpc++/client_context.h include/grpc++/completion_queue.h include/grpc++/config.h include/grpc++/config_protobuf.h include/grpc++/create_channel.h include/grpc++/credentials.h include/grpc++/generic_stub.h include/grpc++/impl/call.h include/grpc++/impl/client_unary_call.h include/grpc++/impl/grpc_library.h include/grpc++/impl/internal_stub.h include/grpc++/impl/proto_utils.h include/grpc++/impl/rpc_method.h include/grpc++/impl/rpc_service_method.h include/grpc++/impl/serialization_traits.h include/grpc++/impl/service_type.h include/grpc++/impl/sync.h include/grpc++/impl/sync_cxx11.h include/grpc++/impl/sync_no_cxx11.h include/grpc++/impl/thd.h include/grpc++/impl/thd_cxx11.h include/grpc++/impl/thd_no_cxx11.h include/grpc++/server.h include/grpc++/server_builder.h include/grpc++/server_context.h include/grpc++/server_credentials.h include/grpc++/slice.h include/grpc++/status.h include/grpc++/status_code_enum.h include/grpc++/stream.h include/grpc++/thread_pool_interface.h include/grpc++/time.h src/cpp/client/secure_credentials.h src/cpp/server/secure_server_credentials.h src/cpp/client/channel.h src/cpp/server/thread_pool.h src/cpp/client/secure_channel_arguments.cc src/cpp/client/secure_credentials.cc src/cpp/server/secure_server_credentials.cc src/cpp/client/channel.cc src/cpp/client/channel_arguments.cc src/cpp/client/client_context.cc src/cpp/client/create_channel.cc src/cpp/client/credentials.cc src/cpp/client/generic_stub.cc src/cpp/client/insecure_credentials.cc src/cpp/client/internal_stub.cc src/cpp/common/call.cc src/cpp/common/completion_queue.cc src/cpp/common/rpc_method.cc src/cpp/proto/proto_utils.cc src/cpp/server/async_generic_service.cc src/cpp/server/create_default_thread_pool.cc src/cpp/server/insecure_server_credentials.cc src/cpp/server/server.cc src/cpp/server/server_builder.cc src/cpp/server/server_context.cc src/cpp/server/server_credentials.cc src/cpp/server/thread_pool.cc src/cpp/util/byte_buffer.cc src/cpp/util/slice.cc src/cpp/util/status.cc src/cpp/util/time.cc # This tag can be used to specify the character encoding of the source files # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses diff --git a/tools/run_tests/check_sources_and_headers.py b/tools/run_tests/check_sources_and_headers.py new file mode 100755 index 0000000000..605bdedec3 --- /dev/null +++ b/tools/run_tests/check_sources_and_headers.py @@ -0,0 +1,55 @@ +#!/usr/bin/env python2.7 + +import json +import os +import re +import sys + +root = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), '../..')) +with open(os.path.join(root, 'tools', 'run_tests', 'sources_and_headers.json')) as f: + js = json.loads(f.read()) + +re_inc1 = re.compile(r'^#\s*include\s*"([^"]*)"') +assert re_inc1.match('#include "foo"').group(1) == 'foo' +re_inc2 = re.compile(r'^#\s*include\s*<((grpc|grpc\+\+)/[^"]*)>') +assert re_inc2.match('#include ').group(1) == 'grpc++/foo' + +def get_target(name): + for target in js: + if target['name'] == name: + return target + assert False, 'no target %s' % name + +def target_has_header(target, name): +# print target['name'], name + if name in target['headers']: + return True + for dep in target['deps']: + if target_has_header(get_target(dep), name): + return True + if name == 'src/core/profiling/stap_probes.h': + return True + return False + +errors = 0 +for target in js: + for fn in target['src']: + with open(os.path.join(root, fn)) as f: + src = f.read().splitlines() + for line in src: + m = re_inc1.match(line) + if m: + if not target_has_header(target, m.group(1)): + print ( + 'target %s (%s) does not name header %s as a dependency' % ( + target['name'], fn, m.group(1))) + errors += 1 + m = re_inc2.match(line) + if m: + if not target_has_header(target, 'include/' + m.group(1)): + print ( + 'target %s (%s) does not name header %s as a dependency' % ( + target['name'], fn, m.group(1))) + errors += 1 + +assert errors == 0 \ No newline at end of file diff --git a/tools/run_tests/run_tests.py b/tools/run_tests/run_tests.py index 5ed70f0b7e..ca74f57f70 100755 --- a/tools/run_tests/run_tests.py +++ b/tools/run_tests/run_tests.py @@ -278,7 +278,8 @@ class CSharpLanguage(object): class Sanity(object): def test_specs(self, config, travis): - return [config.job_spec('tools/run_tests/run_sanity.sh', None)] + return [config.job_spec('tools/run_tests/run_sanity.sh', None), + config.job_spec('tools/run_tests/check_sources_and_headers.py', None)] def make_targets(self): return ['run_dep_checks'] diff --git a/tools/run_tests/sources_and_headers.json b/tools/run_tests/sources_and_headers.json new file mode 100644 index 0000000000..ff985b3734 --- /dev/null +++ b/tools/run_tests/sources_and_headers.json @@ -0,0 +1,10585 @@ + + +[ + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "alarm_heap_test", + "src": [ + "test/core/iomgr/alarm_heap_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "alarm_list_test", + "src": [ + "test/core/iomgr/alarm_list_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "alarm_test", + "src": [ + "test/core/iomgr/alarm_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "alpn_test", + "src": [ + "test/core/transport/chttp2/alpn_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "bin_encoder_test", + "src": [ + "test/core/transport/chttp2/bin_encoder_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_status_conversion_test", + "src": [ + "test/core/transport/chttp2/status_conversion_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_stream_encoder_test", + "src": [ + "test/core/transport/chttp2/stream_encoder_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_stream_map_test", + "src": [ + "test/core/transport/chttp2/stream_map_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "dualstack_socket_test", + "src": [ + "test/core/end2end/dualstack_socket_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "fd_posix_test", + "src": [ + "test/core/iomgr/fd_posix_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "fling_client", + "src": [ + "test/core/fling/client.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "fling_server", + "src": [ + "test/core/fling/server.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "fling_stream_test", + "src": [ + "test/core/fling/fling_stream_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "fling_test", + "src": [ + "test/core/fling/fling_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "gpr", + "grpc" + ], + "headers": [], + "language": "c", + "name": "gen_hpack_tables", + "src": [ + "src/core/transport/chttp2/gen_hpack_tables.c" + ] + }, + { + "deps": [ + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "gpr_cancellable_test", + "src": [ + "test/core/support/cancellable_test.c" + ] + }, + { + "deps": [ + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "gpr_cmdline_test", + "src": [ + "test/core/support/cmdline_test.c" + ] + }, + { + "deps": [ + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "gpr_env_test", + "src": [ + "test/core/support/env_test.c" + ] + }, + { + "deps": [ + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "gpr_file_test", + "src": [ + "test/core/support/file_test.c" + ] + }, + { + "deps": [ + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "gpr_histogram_test", + "src": [ + "test/core/support/histogram_test.c" + ] + }, + { + "deps": [ + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "gpr_host_port_test", + "src": [ + "test/core/support/host_port_test.c" + ] + }, + { + "deps": [ + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "gpr_log_test", + "src": [ + "test/core/support/log_test.c" + ] + }, + { + "deps": [ + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "gpr_slice_buffer_test", + "src": [ + "test/core/support/slice_buffer_test.c" + ] + }, + { + "deps": [ + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "gpr_slice_test", + "src": [ + "test/core/support/slice_test.c" + ] + }, + { + "deps": [ + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "gpr_string_test", + "src": [ + "test/core/support/string_test.c" + ] + }, + { + "deps": [ + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "gpr_sync_test", + "src": [ + "test/core/support/sync_test.c" + ] + }, + { + "deps": [ + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "gpr_thd_test", + "src": [ + "test/core/support/thd_test.c" + ] + }, + { + "deps": [ + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "gpr_time_test", + "src": [ + "test/core/support/time_test.c" + ] + }, + { + "deps": [ + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "gpr_tls_test", + "src": [ + "test/core/support/tls_test.c" + ] + }, + { + "deps": [ + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "gpr_useful_test", + "src": [ + "test/core/support/useful_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "grpc_auth_context_test", + "src": [ + "test/core/security/auth_context_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "grpc_base64_test", + "src": [ + "test/core/security/base64_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "grpc_byte_buffer_reader_test", + "src": [ + "test/core/surface/byte_buffer_reader_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "grpc_channel_stack_test", + "src": [ + "test/core/channel/channel_stack_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "grpc_completion_queue_test", + "src": [ + "test/core/surface/completion_queue_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "grpc_create_jwt", + "src": [ + "test/core/security/create_jwt.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "grpc_credentials_test", + "src": [ + "test/core/security/credentials_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "grpc_fetch_oauth2", + "src": [ + "test/core/security/fetch_oauth2.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "grpc_json_token_test", + "src": [ + "test/core/security/json_token_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "grpc_print_google_default_creds_token", + "src": [ + "test/core/security/print_google_default_creds_token.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "grpc_security_connector_test", + "src": [ + "test/core/security/security_connector_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "grpc_stream_op_test", + "src": [ + "test/core/transport/stream_op_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "hpack_parser_test", + "src": [ + "test/core/transport/chttp2/hpack_parser_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "hpack_table_test", + "src": [ + "test/core/transport/chttp2/hpack_table_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "httpcli_format_request_test", + "src": [ + "test/core/httpcli/format_request_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "httpcli_parser_test", + "src": [ + "test/core/httpcli/parser_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "httpcli_test", + "src": [ + "test/core/httpcli/httpcli_test.c" + ] + }, + { + "deps": [ + "grpc", + "gpr" + ], + "headers": [], + "language": "c", + "name": "json_rewrite", + "src": [ + "test/core/json/json_rewrite.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "json_rewrite_test", + "src": [ + "test/core/json/json_rewrite_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "json_test", + "src": [ + "test/core/json/json_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "lame_client_test", + "src": [ + "test/core/surface/lame_client_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "low_level_ping_pong_benchmark", + "src": [ + "test/core/network_benchmarks/low_level_ping_pong.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "message_compress_test", + "src": [ + "test/core/compression/message_compress_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "multi_init_test", + "src": [ + "test/core/surface/multi_init_test.c" + ] + }, + { + "deps": [ + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "murmur_hash_test", + "src": [ + "test/core/support/murmur_hash_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "no_server_test", + "src": [ + "test/core/end2end/no_server_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "poll_kick_posix_test", + "src": [ + "test/core/iomgr/poll_kick_posix_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "resolve_address_test", + "src": [ + "test/core/iomgr/resolve_address_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "secure_endpoint_test", + "src": [ + "test/core/security/secure_endpoint_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "sockaddr_utils_test", + "src": [ + "test/core/iomgr/sockaddr_utils_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "tcp_client_posix_test", + "src": [ + "test/core/iomgr/tcp_client_posix_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "tcp_posix_test", + "src": [ + "test/core/iomgr/tcp_posix_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "tcp_server_posix_test", + "src": [ + "test/core/iomgr/tcp_server_posix_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "time_averaged_stats_test", + "src": [ + "test/core/iomgr/time_averaged_stats_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "time_test", + "src": [ + "test/core/support/time_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "timeout_encoding_test", + "src": [ + "test/core/transport/chttp2/timeout_encoding_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "timers_test", + "src": [ + "test/core/profiling/timers_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "transport_metadata_test", + "src": [ + "test/core/transport/metadata_test.c" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "transport_security_test", + "src": [ + "test/core/tsi/transport_security_test.c" + ] + }, + { + "deps": [ + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "async_end2end_test", + "src": [ + "test/cpp/end2end/async_end2end_test.cc" + ] + }, + { + "deps": [ + "qps", + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "async_streaming_ping_pong_test", + "src": [ + "test/cpp/qps/async_streaming_ping_pong_test.cc" + ] + }, + { + "deps": [ + "qps", + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "async_unary_ping_pong_test", + "src": [ + "test/cpp/qps/async_unary_ping_pong_test.cc" + ] + }, + { + "deps": [ + "grpc++", + "grpc", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "channel_arguments_test", + "src": [ + "test/cpp/client/channel_arguments_test.cc" + ] + }, + { + "deps": [ + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "cli_call_test", + "src": [ + "test/cpp/util/cli_call_test.cc" + ] + }, + { + "deps": [ + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "client_crash_test", + "src": [ + "test/cpp/end2end/client_crash_test.cc" + ] + }, + { + "deps": [ + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "client_crash_test_server", + "src": [ + "test/cpp/end2end/client_crash_test_server.cc" + ] + }, + { + "deps": [ + "grpc++", + "grpc", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "credentials_test", + "src": [ + "test/cpp/client/credentials_test.cc" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "cxx_byte_buffer_test", + "src": [ + "test/cpp/util/byte_buffer_test.cc" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "cxx_slice_test", + "src": [ + "test/cpp/util/slice_test.cc" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "cxx_time_test", + "src": [ + "test/cpp/util/time_test.cc" + ] + }, + { + "deps": [ + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "end2end_test", + "src": [ + "test/cpp/end2end/end2end_test.cc" + ] + }, + { + "deps": [ + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "generic_end2end_test", + "src": [ + "test/cpp/end2end/generic_end2end_test.cc" + ] + }, + { + "deps": [ + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr", + "grpc++_test_config" + ], + "headers": [], + "language": "c++", + "name": "grpc_cli", + "src": [ + "test/cpp/util/grpc_cli.cc" + ] + }, + { + "deps": [ + "grpc_plugin_support" + ], + "headers": [], + "language": "c++", + "name": "grpc_cpp_plugin", + "src": [ + "src/compiler/cpp_plugin.cc" + ] + }, + { + "deps": [ + "grpc_plugin_support" + ], + "headers": [], + "language": "c++", + "name": "grpc_csharp_plugin", + "src": [ + "src/compiler/csharp_plugin.cc" + ] + }, + { + "deps": [ + "grpc_plugin_support" + ], + "headers": [], + "language": "c++", + "name": "grpc_objective_c_plugin", + "src": [ + "src/compiler/objective_c_plugin.cc" + ] + }, + { + "deps": [ + "grpc_plugin_support" + ], + "headers": [], + "language": "c++", + "name": "grpc_python_plugin", + "src": [ + "src/compiler/python_plugin.cc" + ] + }, + { + "deps": [ + "grpc_plugin_support" + ], + "headers": [], + "language": "c++", + "name": "grpc_ruby_plugin", + "src": [ + "src/compiler/ruby_plugin.cc" + ] + }, + { + "deps": [ + "interop_client_main", + "interop_client_helper", + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr", + "grpc++_test_config" + ], + "headers": [], + "language": "c++", + "name": "interop_client", + "src": [] + }, + { + "deps": [ + "interop_server_main", + "interop_server_helper", + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr", + "grpc++_test_config" + ], + "headers": [], + "language": "c++", + "name": "interop_server", + "src": [] + }, + { + "deps": [ + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "interop_test", + "src": [ + "test/cpp/interop/interop_test.cc" + ] + }, + { + "deps": [ + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "mock_test", + "src": [ + "test/cpp/end2end/mock_test.cc" + ] + }, + { + "deps": [ + "pubsub_client_lib", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr", + "grpc++_test_config" + ], + "headers": [], + "language": "c++", + "name": "pubsub_client", + "src": [ + "examples/pubsub/main.cc" + ] + }, + { + "deps": [ + "pubsub_client_lib", + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "pubsub_publisher_test", + "src": [ + "examples/pubsub/publisher_test.cc" + ] + }, + { + "deps": [ + "pubsub_client_lib", + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "pubsub_subscriber_test", + "src": [ + "examples/pubsub/subscriber_test.cc" + ] + }, + { + "deps": [ + "qps", + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr", + "grpc++_test_config" + ], + "headers": [], + "language": "c++", + "name": "qps_driver", + "src": [ + "test/cpp/qps/qps_driver.cc" + ] + }, + { + "deps": [ + "qps", + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "qps_interarrival_test", + "src": [ + "test/cpp/qps/qps_interarrival_test.cc" + ] + }, + { + "deps": [ + "qps", + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr", + "grpc++_test_config" + ], + "headers": [], + "language": "c++", + "name": "qps_test", + "src": [ + "test/cpp/qps/qps_test.cc" + ] + }, + { + "deps": [ + "qps", + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr", + "grpc++_test_config" + ], + "headers": [], + "language": "c++", + "name": "qps_test_openloop", + "src": [ + "test/cpp/qps/qps_test_openloop.cc" + ] + }, + { + "deps": [ + "qps", + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr", + "grpc++_test_config" + ], + "headers": [ + "test/cpp/qps/client.h", + "test/cpp/qps/server.h" + ], + "language": "c++", + "name": "qps_worker", + "src": [ + "test/cpp/qps/worker.cc", + "test/cpp/qps/client.h", + "test/cpp/qps/server.h" + ] + }, + { + "deps": [ + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "server_crash_test", + "src": [ + "test/cpp/end2end/server_crash_test.cc" + ] + }, + { + "deps": [ + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "server_crash_test_client", + "src": [ + "test/cpp/end2end/server_crash_test_client.cc" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "status_test", + "src": [ + "test/cpp/util/status_test.cc" + ] + }, + { + "deps": [ + "qps", + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "sync_streaming_ping_pong_test", + "src": [ + "test/cpp/qps/sync_streaming_ping_pong_test.cc" + ] + }, + { + "deps": [ + "qps", + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "sync_unary_ping_pong_test", + "src": [ + "test/cpp/qps/sync_unary_ping_pong_test.cc" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "thread_pool_test", + "src": [ + "test/cpp/server/thread_pool_test.cc" + ] + }, + { + "deps": [ + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c++", + "name": "thread_stress_test", + "src": [ + "test/cpp/end2end/thread_stress_test.cc" + ] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_bad_hostname", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_bad_hostname_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_cancel_after_accept", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_cancel_after_accept_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_cancel_after_accept_and_writes_closed", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_cancel_after_accept_and_writes_closed_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_cancel_after_invoke", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_cancel_after_invoke_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_cancel_before_invoke", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_cancel_before_invoke_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_cancel_in_a_vacuum", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_cancel_in_a_vacuum_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_census_simple_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_census_simple_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_disappearing_server", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_disappearing_server_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_early_server_shutdown_finishes_inflight_calls", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_early_server_shutdown_finishes_inflight_calls_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_early_server_shutdown_finishes_tags", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_early_server_shutdown_finishes_tags_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_empty_batch", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_empty_batch_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_graceful_server_shutdown", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_graceful_server_shutdown_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_invoke_large_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_invoke_large_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_max_concurrent_streams", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_max_concurrent_streams_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_max_message_length", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_max_message_length_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_no_op", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_no_op_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_ping_pong_streaming", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_ping_pong_streaming_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_registered_call", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_registered_call_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_request_response_with_binary_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_request_response_with_binary_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_request_response_with_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_request_response_with_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_request_response_with_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_request_response_with_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_request_response_with_payload_and_call_creds", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_request_response_with_payload_and_call_creds_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_request_response_with_trailing_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_request_response_with_trailing_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_request_with_flags", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_request_with_flags_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_request_with_large_metadata", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_request_with_large_metadata_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_request_with_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_request_with_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_server_finishes_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_server_finishes_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_simple_delayed_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_simple_delayed_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_simple_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_simple_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fake_security", + "end2end_test_simple_request_with_high_initial_sequence_number", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fake_security_simple_request_with_high_initial_sequence_number_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_bad_hostname", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_bad_hostname_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_cancel_after_accept", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_cancel_after_accept_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_cancel_after_accept_and_writes_closed", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_cancel_after_accept_and_writes_closed_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_cancel_after_invoke", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_cancel_after_invoke_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_cancel_before_invoke", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_cancel_before_invoke_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_cancel_in_a_vacuum", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_cancel_in_a_vacuum_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_census_simple_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_census_simple_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_disappearing_server", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_disappearing_server_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_early_server_shutdown_finishes_inflight_calls", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_early_server_shutdown_finishes_inflight_calls_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_early_server_shutdown_finishes_tags", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_early_server_shutdown_finishes_tags_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_empty_batch", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_empty_batch_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_graceful_server_shutdown", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_graceful_server_shutdown_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_invoke_large_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_invoke_large_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_max_concurrent_streams", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_max_concurrent_streams_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_max_message_length", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_max_message_length_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_no_op", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_no_op_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_ping_pong_streaming", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_ping_pong_streaming_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_registered_call", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_registered_call_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_request_response_with_binary_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_request_response_with_binary_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_request_response_with_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_request_response_with_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_request_response_with_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_request_response_with_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_request_response_with_payload_and_call_creds", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_request_response_with_payload_and_call_creds_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_request_response_with_trailing_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_request_response_with_trailing_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_request_with_flags", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_request_with_flags_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_request_with_large_metadata", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_request_with_large_metadata_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_request_with_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_request_with_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_server_finishes_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_server_finishes_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_simple_delayed_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_simple_delayed_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_simple_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_simple_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_simple_request_with_high_initial_sequence_number", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_simple_request_with_high_initial_sequence_number_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_bad_hostname", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_bad_hostname_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_cancel_after_accept", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_cancel_after_accept_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_cancel_after_accept_and_writes_closed", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_cancel_after_accept_and_writes_closed_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_cancel_after_invoke", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_cancel_after_invoke_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_cancel_before_invoke", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_cancel_before_invoke_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_cancel_in_a_vacuum", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_cancel_in_a_vacuum_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_census_simple_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_census_simple_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_disappearing_server", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_disappearing_server_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_early_server_shutdown_finishes_inflight_calls", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_early_server_shutdown_finishes_inflight_calls_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_early_server_shutdown_finishes_tags", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_early_server_shutdown_finishes_tags_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_empty_batch", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_empty_batch_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_graceful_server_shutdown", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_graceful_server_shutdown_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_invoke_large_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_invoke_large_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_max_concurrent_streams", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_max_concurrent_streams_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_max_message_length", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_max_message_length_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_no_op", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_no_op_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_ping_pong_streaming", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_ping_pong_streaming_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_registered_call", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_registered_call_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_request_response_with_binary_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_request_response_with_binary_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_request_response_with_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_request_response_with_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_request_response_with_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_request_response_with_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_request_response_with_payload_and_call_creds", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_request_response_with_payload_and_call_creds_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_request_response_with_trailing_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_request_response_with_trailing_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_request_with_flags", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_request_with_flags_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_request_with_large_metadata", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_request_with_large_metadata_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_request_with_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_request_with_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_server_finishes_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_server_finishes_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_simple_delayed_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_simple_delayed_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_simple_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_simple_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_simple_request_with_high_initial_sequence_number", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_simple_request_with_high_initial_sequence_number_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_bad_hostname", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_bad_hostname_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_cancel_after_accept", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_cancel_after_accept_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_cancel_after_accept_and_writes_closed", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_cancel_after_accept_and_writes_closed_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_cancel_after_invoke", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_cancel_after_invoke_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_cancel_before_invoke", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_cancel_before_invoke_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_cancel_in_a_vacuum", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_cancel_in_a_vacuum_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_census_simple_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_census_simple_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_disappearing_server", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_disappearing_server_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_early_server_shutdown_finishes_inflight_calls", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_early_server_shutdown_finishes_inflight_calls_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_early_server_shutdown_finishes_tags", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_early_server_shutdown_finishes_tags_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_empty_batch", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_empty_batch_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_graceful_server_shutdown", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_graceful_server_shutdown_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_invoke_large_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_invoke_large_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_max_concurrent_streams", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_max_concurrent_streams_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_max_message_length", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_max_message_length_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_no_op", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_no_op_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_ping_pong_streaming", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_ping_pong_streaming_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_registered_call", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_registered_call_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_request_response_with_binary_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_request_response_with_binary_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_request_response_with_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_request_response_with_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_request_response_with_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_request_response_with_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_request_response_with_payload_and_call_creds", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_request_response_with_payload_and_call_creds_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_request_response_with_trailing_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_request_response_with_trailing_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_request_with_flags", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_request_with_flags_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_request_with_large_metadata", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_request_with_large_metadata_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_request_with_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_request_with_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_server_finishes_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_server_finishes_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_simple_delayed_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_simple_delayed_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_simple_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_simple_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_simple_request_with_high_initial_sequence_number", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_simple_request_with_high_initial_sequence_number_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_bad_hostname", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_bad_hostname_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_cancel_after_accept", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_cancel_after_accept_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_cancel_after_accept_and_writes_closed", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_cancel_after_accept_and_writes_closed_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_cancel_after_invoke", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_cancel_after_invoke_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_cancel_before_invoke", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_cancel_before_invoke_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_cancel_in_a_vacuum", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_cancel_in_a_vacuum_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_census_simple_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_census_simple_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_disappearing_server", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_disappearing_server_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_early_server_shutdown_finishes_inflight_calls", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_early_server_shutdown_finishes_inflight_calls_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_early_server_shutdown_finishes_tags", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_early_server_shutdown_finishes_tags_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_empty_batch", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_empty_batch_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_graceful_server_shutdown", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_graceful_server_shutdown_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_invoke_large_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_invoke_large_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_max_concurrent_streams", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_max_concurrent_streams_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_max_message_length", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_max_message_length_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_no_op", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_no_op_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_ping_pong_streaming", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_ping_pong_streaming_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_registered_call", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_registered_call_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_request_response_with_binary_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_request_response_with_binary_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_request_response_with_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_request_response_with_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_request_response_with_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_request_response_with_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_request_response_with_payload_and_call_creds", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_request_response_with_payload_and_call_creds_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_request_response_with_trailing_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_request_response_with_trailing_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_request_with_flags", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_request_with_flags_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_request_with_large_metadata", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_request_with_large_metadata_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_request_with_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_request_with_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_server_finishes_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_server_finishes_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_simple_delayed_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_simple_delayed_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_simple_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_simple_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack", + "end2end_test_simple_request_with_high_initial_sequence_number", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_simple_request_with_high_initial_sequence_number_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_bad_hostname", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_bad_hostname_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_cancel_after_accept", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_cancel_after_accept_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_cancel_after_accept_and_writes_closed", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_cancel_after_accept_and_writes_closed_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_cancel_after_invoke", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_cancel_after_invoke_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_cancel_before_invoke", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_cancel_before_invoke_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_cancel_in_a_vacuum", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_cancel_in_a_vacuum_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_census_simple_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_census_simple_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_disappearing_server", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_disappearing_server_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_early_server_shutdown_finishes_inflight_calls", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_early_server_shutdown_finishes_inflight_calls_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_early_server_shutdown_finishes_tags", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_early_server_shutdown_finishes_tags_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_empty_batch", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_empty_batch_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_graceful_server_shutdown", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_graceful_server_shutdown_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_invoke_large_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_invoke_large_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_max_concurrent_streams", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_max_concurrent_streams_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_max_message_length", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_max_message_length_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_no_op", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_no_op_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_ping_pong_streaming", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_ping_pong_streaming_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_registered_call", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_registered_call_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_request_response_with_binary_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_request_response_with_binary_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_request_response_with_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_request_response_with_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_request_response_with_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_request_response_with_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_request_response_with_payload_and_call_creds", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_request_response_with_payload_and_call_creds_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_request_response_with_trailing_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_request_response_with_trailing_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_request_with_flags", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_request_with_flags_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_request_with_large_metadata", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_request_with_large_metadata_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_request_with_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_request_with_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_server_finishes_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_server_finishes_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_simple_delayed_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_simple_delayed_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_simple_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_simple_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "end2end_test_simple_request_with_high_initial_sequence_number", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_fullstack_with_poll_simple_request_with_high_initial_sequence_number_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_bad_hostname", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_bad_hostname_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_cancel_after_accept", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_cancel_after_accept_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_cancel_after_accept_and_writes_closed", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_cancel_after_accept_and_writes_closed_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_cancel_after_invoke", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_cancel_after_invoke_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_cancel_before_invoke", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_cancel_before_invoke_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_cancel_in_a_vacuum", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_cancel_in_a_vacuum_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_census_simple_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_census_simple_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_disappearing_server", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_disappearing_server_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_early_server_shutdown_finishes_inflight_calls", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_early_server_shutdown_finishes_inflight_calls_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_early_server_shutdown_finishes_tags", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_early_server_shutdown_finishes_tags_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_empty_batch", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_empty_batch_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_graceful_server_shutdown", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_graceful_server_shutdown_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_invoke_large_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_invoke_large_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_max_concurrent_streams", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_max_concurrent_streams_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_max_message_length", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_max_message_length_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_no_op", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_no_op_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_ping_pong_streaming", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_ping_pong_streaming_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_registered_call", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_registered_call_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_request_response_with_binary_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_request_response_with_binary_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_request_response_with_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_request_response_with_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_request_response_with_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_request_response_with_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_request_response_with_payload_and_call_creds", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_request_response_with_payload_and_call_creds_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_request_response_with_trailing_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_request_response_with_trailing_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_request_with_flags", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_request_with_flags_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_request_with_large_metadata", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_request_with_large_metadata_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_request_with_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_request_with_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_server_finishes_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_server_finishes_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_simple_delayed_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_simple_delayed_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_simple_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_simple_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "end2end_test_simple_request_with_high_initial_sequence_number", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_simple_ssl_with_oauth2_fullstack_simple_request_with_high_initial_sequence_number_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_bad_hostname", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_bad_hostname_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_cancel_after_accept", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_cancel_after_accept_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_cancel_after_accept_and_writes_closed", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_cancel_after_accept_and_writes_closed_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_cancel_after_invoke", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_cancel_after_invoke_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_cancel_before_invoke", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_cancel_before_invoke_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_cancel_in_a_vacuum", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_cancel_in_a_vacuum_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_census_simple_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_census_simple_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_disappearing_server", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_disappearing_server_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_early_server_shutdown_finishes_inflight_calls", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_early_server_shutdown_finishes_inflight_calls_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_early_server_shutdown_finishes_tags", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_early_server_shutdown_finishes_tags_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_empty_batch", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_empty_batch_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_graceful_server_shutdown", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_graceful_server_shutdown_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_invoke_large_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_invoke_large_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_max_concurrent_streams", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_max_concurrent_streams_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_max_message_length", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_max_message_length_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_no_op", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_no_op_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_ping_pong_streaming", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_ping_pong_streaming_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_registered_call", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_registered_call_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_request_response_with_binary_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_request_response_with_binary_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_request_response_with_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_request_response_with_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_request_response_with_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_request_response_with_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_request_response_with_payload_and_call_creds", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_request_response_with_payload_and_call_creds_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_request_response_with_trailing_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_request_response_with_trailing_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_request_with_flags", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_request_with_flags_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_request_with_large_metadata", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_request_with_large_metadata_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_request_with_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_request_with_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_server_finishes_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_server_finishes_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_simple_delayed_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_simple_delayed_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_simple_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_simple_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_simple_request_with_high_initial_sequence_number", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_simple_request_with_high_initial_sequence_number_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_bad_hostname", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_bad_hostname_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_cancel_after_accept", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_cancel_after_accept_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_cancel_after_accept_and_writes_closed", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_cancel_after_accept_and_writes_closed_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_cancel_after_invoke", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_cancel_after_invoke_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_cancel_before_invoke", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_cancel_before_invoke_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_cancel_in_a_vacuum", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_cancel_in_a_vacuum_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_census_simple_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_census_simple_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_disappearing_server", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_disappearing_server_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_early_server_shutdown_finishes_inflight_calls", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_early_server_shutdown_finishes_inflight_calls_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_early_server_shutdown_finishes_tags", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_early_server_shutdown_finishes_tags_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_empty_batch", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_empty_batch_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_graceful_server_shutdown", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_graceful_server_shutdown_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_invoke_large_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_invoke_large_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_max_concurrent_streams", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_max_concurrent_streams_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_max_message_length", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_max_message_length_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_no_op", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_no_op_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_ping_pong_streaming", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_ping_pong_streaming_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_registered_call", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_registered_call_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_request_response_with_binary_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_request_response_with_binary_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_request_response_with_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_request_response_with_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_request_response_with_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_request_response_with_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_request_response_with_payload_and_call_creds", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_request_response_with_payload_and_call_creds_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_request_response_with_trailing_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_request_response_with_trailing_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_request_with_flags", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_request_with_flags_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_request_with_large_metadata", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_request_with_large_metadata_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_request_with_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_request_with_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_server_finishes_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_server_finishes_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_simple_delayed_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_simple_delayed_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_simple_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_simple_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_simple_request_with_high_initial_sequence_number", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_simple_request_with_high_initial_sequence_number_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_bad_hostname", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_bad_hostname_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_cancel_after_accept", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_cancel_after_accept_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_cancel_after_accept_and_writes_closed", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_cancel_after_accept_and_writes_closed_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_cancel_after_invoke", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_cancel_after_invoke_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_cancel_before_invoke", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_cancel_before_invoke_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_cancel_in_a_vacuum", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_cancel_in_a_vacuum_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_census_simple_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_census_simple_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_disappearing_server", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_disappearing_server_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_early_server_shutdown_finishes_inflight_calls", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_early_server_shutdown_finishes_inflight_calls_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_early_server_shutdown_finishes_tags", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_early_server_shutdown_finishes_tags_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_empty_batch", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_empty_batch_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_graceful_server_shutdown", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_graceful_server_shutdown_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_invoke_large_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_invoke_large_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_max_concurrent_streams", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_max_concurrent_streams_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_max_message_length", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_max_message_length_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_no_op", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_no_op_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_ping_pong_streaming", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_ping_pong_streaming_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_registered_call", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_registered_call_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_request_response_with_binary_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_request_response_with_binary_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_request_response_with_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_request_response_with_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_request_response_with_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_request_response_with_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_request_response_with_payload_and_call_creds", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_request_response_with_payload_and_call_creds_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_request_response_with_trailing_metadata_and_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_request_response_with_trailing_metadata_and_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_request_with_flags", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_request_with_flags_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_request_with_large_metadata", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_request_with_large_metadata_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_request_with_payload", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_request_with_payload_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_server_finishes_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_server_finishes_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_simple_delayed_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_simple_delayed_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_simple_request", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_simple_request_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_simple_request_with_high_initial_sequence_number", + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_simple_request_with_high_initial_sequence_number_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_bad_hostname", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_bad_hostname_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_cancel_after_accept", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_cancel_after_accept_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_cancel_after_accept_and_writes_closed", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_cancel_after_accept_and_writes_closed_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_cancel_after_invoke", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_cancel_after_invoke_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_cancel_before_invoke", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_cancel_before_invoke_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_cancel_in_a_vacuum", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_cancel_in_a_vacuum_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_census_simple_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_census_simple_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_disappearing_server", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_disappearing_server_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_early_server_shutdown_finishes_inflight_calls", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_early_server_shutdown_finishes_inflight_calls_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_early_server_shutdown_finishes_tags", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_early_server_shutdown_finishes_tags_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_empty_batch", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_empty_batch_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_graceful_server_shutdown", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_graceful_server_shutdown_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_invoke_large_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_invoke_large_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_max_concurrent_streams", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_max_concurrent_streams_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_max_message_length", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_max_message_length_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_no_op", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_no_op_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_ping_pong_streaming", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_ping_pong_streaming_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_registered_call", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_registered_call_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_request_response_with_binary_metadata_and_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_request_response_with_binary_metadata_and_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_request_response_with_metadata_and_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_request_response_with_metadata_and_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_request_response_with_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_request_response_with_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_request_response_with_trailing_metadata_and_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_request_response_with_trailing_metadata_and_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_request_with_flags", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_request_with_flags_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_request_with_large_metadata", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_request_with_large_metadata_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_request_with_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_request_with_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_server_finishes_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_server_finishes_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_simple_delayed_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_simple_delayed_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_simple_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_simple_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack", + "end2end_test_simple_request_with_high_initial_sequence_number", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_simple_request_with_high_initial_sequence_number_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_bad_hostname", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_bad_hostname_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_cancel_after_accept", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_cancel_after_accept_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_cancel_after_accept_and_writes_closed", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_cancel_after_accept_and_writes_closed_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_cancel_after_invoke", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_cancel_after_invoke_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_cancel_before_invoke", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_cancel_before_invoke_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_cancel_in_a_vacuum", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_cancel_in_a_vacuum_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_census_simple_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_census_simple_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_disappearing_server", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_disappearing_server_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_early_server_shutdown_finishes_inflight_calls", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_early_server_shutdown_finishes_inflight_calls_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_early_server_shutdown_finishes_tags", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_early_server_shutdown_finishes_tags_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_empty_batch", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_empty_batch_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_graceful_server_shutdown", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_graceful_server_shutdown_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_invoke_large_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_invoke_large_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_max_concurrent_streams", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_max_concurrent_streams_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_max_message_length", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_max_message_length_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_no_op", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_no_op_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_ping_pong_streaming", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_ping_pong_streaming_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_registered_call", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_registered_call_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_request_response_with_binary_metadata_and_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_request_response_with_binary_metadata_and_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_request_response_with_metadata_and_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_request_response_with_metadata_and_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_request_response_with_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_request_response_with_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_request_response_with_trailing_metadata_and_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_request_response_with_trailing_metadata_and_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_request_with_flags", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_request_with_flags_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_request_with_large_metadata", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_request_with_large_metadata_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_request_with_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_request_with_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_server_finishes_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_server_finishes_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_simple_delayed_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_simple_delayed_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_simple_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_simple_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_uds_posix", + "end2end_test_simple_request_with_high_initial_sequence_number", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_uds_posix_simple_request_with_high_initial_sequence_number_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_bad_hostname", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_bad_hostname_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_cancel_after_accept", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_cancel_after_accept_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_cancel_after_accept_and_writes_closed", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_cancel_after_accept_and_writes_closed_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_cancel_after_invoke", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_cancel_after_invoke_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_cancel_before_invoke", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_cancel_before_invoke_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_cancel_in_a_vacuum", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_cancel_in_a_vacuum_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_census_simple_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_census_simple_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_disappearing_server", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_disappearing_server_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_early_server_shutdown_finishes_inflight_calls", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_early_server_shutdown_finishes_inflight_calls_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_early_server_shutdown_finishes_tags", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_early_server_shutdown_finishes_tags_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_empty_batch", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_empty_batch_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_graceful_server_shutdown", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_graceful_server_shutdown_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_invoke_large_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_invoke_large_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_max_concurrent_streams", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_max_concurrent_streams_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_max_message_length", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_max_message_length_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_no_op", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_no_op_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_ping_pong_streaming", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_ping_pong_streaming_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_registered_call", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_registered_call_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_request_response_with_binary_metadata_and_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_request_response_with_binary_metadata_and_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_request_response_with_metadata_and_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_request_response_with_metadata_and_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_request_response_with_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_request_response_with_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_request_response_with_trailing_metadata_and_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_request_response_with_trailing_metadata_and_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_request_with_flags", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_request_with_flags_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_request_with_large_metadata", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_request_with_large_metadata_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_request_with_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_request_with_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_server_finishes_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_server_finishes_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_simple_delayed_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_simple_delayed_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_simple_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_simple_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_fullstack_with_poll", + "end2end_test_simple_request_with_high_initial_sequence_number", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_fullstack_with_poll_simple_request_with_high_initial_sequence_number_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_bad_hostname", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_bad_hostname_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_cancel_after_accept", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_cancel_after_accept_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_cancel_after_accept_and_writes_closed", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_cancel_after_accept_and_writes_closed_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_cancel_after_invoke", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_cancel_after_invoke_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_cancel_before_invoke", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_cancel_before_invoke_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_cancel_in_a_vacuum", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_cancel_in_a_vacuum_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_census_simple_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_census_simple_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_disappearing_server", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_disappearing_server_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_early_server_shutdown_finishes_inflight_calls", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_early_server_shutdown_finishes_inflight_calls_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_early_server_shutdown_finishes_tags", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_early_server_shutdown_finishes_tags_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_empty_batch", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_empty_batch_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_graceful_server_shutdown", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_graceful_server_shutdown_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_invoke_large_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_invoke_large_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_max_concurrent_streams", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_max_concurrent_streams_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_max_message_length", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_max_message_length_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_no_op", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_no_op_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_ping_pong_streaming", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_ping_pong_streaming_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_registered_call", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_registered_call_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_request_response_with_binary_metadata_and_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_request_response_with_binary_metadata_and_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_request_response_with_metadata_and_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_request_response_with_metadata_and_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_request_response_with_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_request_response_with_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_request_response_with_trailing_metadata_and_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_request_response_with_trailing_metadata_and_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_request_with_flags", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_request_with_flags_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_request_with_large_metadata", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_request_with_large_metadata_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_request_with_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_request_with_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_server_finishes_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_server_finishes_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_simple_delayed_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_simple_delayed_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_simple_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_simple_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair", + "end2end_test_simple_request_with_high_initial_sequence_number", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_simple_request_with_high_initial_sequence_number_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_bad_hostname", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_bad_hostname_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_cancel_after_accept", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_cancel_after_accept_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_cancel_after_accept_and_writes_closed", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_cancel_after_accept_and_writes_closed_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_cancel_after_invoke", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_cancel_after_invoke_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_cancel_before_invoke", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_cancel_before_invoke_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_cancel_in_a_vacuum", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_cancel_in_a_vacuum_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_census_simple_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_census_simple_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_disappearing_server", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_disappearing_server_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_early_server_shutdown_finishes_inflight_calls", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_early_server_shutdown_finishes_inflight_calls_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_early_server_shutdown_finishes_tags", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_early_server_shutdown_finishes_tags_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_empty_batch", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_empty_batch_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_graceful_server_shutdown", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_graceful_server_shutdown_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_invoke_large_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_invoke_large_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_max_concurrent_streams", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_max_concurrent_streams_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_max_message_length", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_max_message_length_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_no_op", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_no_op_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_ping_pong_streaming", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_ping_pong_streaming_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_registered_call", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_registered_call_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_request_response_with_binary_metadata_and_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_request_response_with_binary_metadata_and_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_request_response_with_metadata_and_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_request_response_with_metadata_and_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_request_response_with_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_request_response_with_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_request_response_with_trailing_metadata_and_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_request_response_with_trailing_metadata_and_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_request_with_flags", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_request_with_flags_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_request_with_large_metadata", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_request_with_large_metadata_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_request_with_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_request_with_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_server_finishes_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_server_finishes_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_simple_delayed_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_simple_delayed_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_simple_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_simple_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "end2end_test_simple_request_with_high_initial_sequence_number", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_one_byte_at_a_time_simple_request_with_high_initial_sequence_number_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_bad_hostname", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_bad_hostname_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_cancel_after_accept", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_cancel_after_accept_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_cancel_after_accept_and_writes_closed", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_cancel_after_accept_and_writes_closed_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_cancel_after_invoke", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_cancel_after_invoke_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_cancel_before_invoke", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_cancel_before_invoke_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_cancel_in_a_vacuum", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_cancel_in_a_vacuum_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_census_simple_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_census_simple_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_disappearing_server", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_disappearing_server_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_early_server_shutdown_finishes_inflight_calls", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_early_server_shutdown_finishes_inflight_calls_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_early_server_shutdown_finishes_tags", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_early_server_shutdown_finishes_tags_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_empty_batch", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_empty_batch_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_graceful_server_shutdown", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_graceful_server_shutdown_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_invoke_large_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_invoke_large_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_max_concurrent_streams", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_max_concurrent_streams_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_max_message_length", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_max_message_length_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_no_op", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_no_op_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_ping_pong_streaming", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_ping_pong_streaming_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_registered_call", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_registered_call_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_request_response_with_binary_metadata_and_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_request_response_with_binary_metadata_and_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_request_response_with_metadata_and_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_request_response_with_metadata_and_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_request_response_with_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_request_response_with_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_request_response_with_trailing_metadata_and_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_request_response_with_trailing_metadata_and_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_request_with_flags", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_request_with_flags_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_request_with_large_metadata", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_request_with_large_metadata_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_request_with_payload", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_request_with_payload_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_server_finishes_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_server_finishes_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_simple_delayed_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_simple_delayed_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_simple_request", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_simple_request_unsecure_test", + "src": [] + }, + { + "deps": [ + "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "end2end_test_simple_request_with_high_initial_sequence_number", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "chttp2_socket_pair_with_grpc_trace_simple_request_with_high_initial_sequence_number_unsecure_test", + "src": [] + }, + { + "deps": [ + "bad_client_test", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "connection_prefix_bad_client_test", + "src": [ + "test/core/bad_client/tests/connection_prefix.c" + ] + }, + { + "deps": [ + "bad_client_test", + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [], + "language": "c", + "name": "initial_settings_frame_bad_client_test", + "src": [ + "test/core/bad_client/tests/initial_settings_frame.c" + ] + }, + { + "deps": [], + "headers": [ + "include/grpc/support/alloc.h", + "include/grpc/support/atm.h", + "include/grpc/support/atm_gcc_atomic.h", + "include/grpc/support/atm_gcc_sync.h", + "include/grpc/support/atm_win32.h", + "include/grpc/support/cancellable_platform.h", + "include/grpc/support/cmdline.h", + "include/grpc/support/cpu.h", + "include/grpc/support/histogram.h", + "include/grpc/support/host_port.h", + "include/grpc/support/log.h", + "include/grpc/support/log_win32.h", + "include/grpc/support/port_platform.h", + "include/grpc/support/slice.h", + "include/grpc/support/slice_buffer.h", + "include/grpc/support/string_util.h", + "include/grpc/support/subprocess.h", + "include/grpc/support/sync.h", + "include/grpc/support/sync_generic.h", + "include/grpc/support/sync_posix.h", + "include/grpc/support/sync_win32.h", + "include/grpc/support/thd.h", + "include/grpc/support/time.h", + "include/grpc/support/tls.h", + "include/grpc/support/tls_gcc.h", + "include/grpc/support/tls_msvc.h", + "include/grpc/support/tls_pthread.h", + "include/grpc/support/useful.h", + "src/core/support/env.h", + "src/core/support/file.h", + "src/core/support/murmur_hash.h", + "src/core/support/string.h", + "src/core/support/string_win32.h", + "src/core/support/thd_internal.h" + ], + "language": "c", + "name": "gpr", + "src": [ + "src/core/support/alloc.c", + "src/core/support/cancellable.c", + "src/core/support/cmdline.c", + "src/core/support/cpu_iphone.c", + "src/core/support/cpu_linux.c", + "src/core/support/cpu_posix.c", + "src/core/support/cpu_windows.c", + "src/core/support/env_linux.c", + "src/core/support/env_posix.c", + "src/core/support/env_win32.c", + "src/core/support/file.c", + "src/core/support/file_posix.c", + "src/core/support/file_win32.c", + "src/core/support/histogram.c", + "src/core/support/host_port.c", + "src/core/support/log.c", + "src/core/support/log_android.c", + "src/core/support/log_linux.c", + "src/core/support/log_posix.c", + "src/core/support/log_win32.c", + "src/core/support/murmur_hash.c", + "src/core/support/slice.c", + "src/core/support/slice_buffer.c", + "src/core/support/string.c", + "src/core/support/string_posix.c", + "src/core/support/string_win32.c", + "src/core/support/subprocess_posix.c", + "src/core/support/sync.c", + "src/core/support/sync_posix.c", + "src/core/support/sync_win32.c", + "src/core/support/thd.c", + "src/core/support/thd_posix.c", + "src/core/support/thd_win32.c", + "src/core/support/time.c", + "src/core/support/time_posix.c", + "src/core/support/time_win32.c", + "src/core/support/tls_pthread.c", + "include/grpc/support/alloc.h", + "include/grpc/support/atm.h", + "include/grpc/support/atm_gcc_atomic.h", + "include/grpc/support/atm_gcc_sync.h", + "include/grpc/support/atm_win32.h", + "include/grpc/support/cancellable_platform.h", + "include/grpc/support/cmdline.h", + "include/grpc/support/cpu.h", + "include/grpc/support/histogram.h", + "include/grpc/support/host_port.h", + "include/grpc/support/log.h", + "include/grpc/support/log_win32.h", + "include/grpc/support/port_platform.h", + "include/grpc/support/slice.h", + "include/grpc/support/slice_buffer.h", + "include/grpc/support/string_util.h", + "include/grpc/support/subprocess.h", + "include/grpc/support/sync.h", + "include/grpc/support/sync_generic.h", + "include/grpc/support/sync_posix.h", + "include/grpc/support/sync_win32.h", + "include/grpc/support/thd.h", + "include/grpc/support/time.h", + "include/grpc/support/tls.h", + "include/grpc/support/tls_gcc.h", + "include/grpc/support/tls_msvc.h", + "include/grpc/support/tls_pthread.h", + "include/grpc/support/useful.h", + "src/core/support/env.h", + "src/core/support/file.h", + "src/core/support/murmur_hash.h", + "src/core/support/string.h", + "src/core/support/string_win32.h", + "src/core/support/thd_internal.h" + ] + }, + { + "deps": [ + "gpr" + ], + "headers": [ + "test/core/util/test_config.h" + ], + "language": "c", + "name": "gpr_test_util", + "src": [ + "test/core/util/test_config.c", + "test/core/util/test_config.h" + ] + }, + { + "deps": [ + "gpr" + ], + "headers": [ + "include/grpc/grpc_security.h", + "include/grpc/byte_buffer.h", + "include/grpc/byte_buffer_reader.h", + "include/grpc/compression.h", + "include/grpc/grpc.h", + "include/grpc/status.h", + "include/grpc/census.h", + "src/core/httpcli/format_request.h", + "src/core/httpcli/httpcli.h", + "src/core/httpcli/httpcli_security_connector.h", + "src/core/httpcli/parser.h", + "src/core/security/auth_filters.h", + "src/core/security/base64.h", + "src/core/security/credentials.h", + "src/core/security/json_token.h", + "src/core/security/secure_endpoint.h", + "src/core/security/secure_transport_setup.h", + "src/core/security/security_connector.h", + "src/core/security/security_context.h", + "src/core/tsi/fake_transport_security.h", + "src/core/tsi/ssl_transport_security.h", + "src/core/tsi/transport_security.h", + "src/core/tsi/transport_security_interface.h", + "src/core/census/grpc_context.h", + "src/core/channel/census_filter.h", + "src/core/channel/channel_args.h", + "src/core/channel/channel_stack.h", + "src/core/channel/child_channel.h", + "src/core/channel/client_channel.h", + "src/core/channel/client_setup.h", + "src/core/channel/connected_channel.h", + "src/core/channel/context.h", + "src/core/channel/http_client_filter.h", + "src/core/channel/http_server_filter.h", + "src/core/channel/noop_filter.h", + "src/core/compression/message_compress.h", + "src/core/debug/trace.h", + "src/core/iomgr/alarm.h", + "src/core/iomgr/alarm_heap.h", + "src/core/iomgr/alarm_internal.h", + "src/core/iomgr/endpoint.h", + "src/core/iomgr/endpoint_pair.h", + "src/core/iomgr/fd_posix.h", + "src/core/iomgr/iocp_windows.h", + "src/core/iomgr/iomgr.h", + "src/core/iomgr/iomgr_internal.h", + "src/core/iomgr/iomgr_posix.h", + "src/core/iomgr/pollset.h", + "src/core/iomgr/pollset_kick_posix.h", + "src/core/iomgr/pollset_posix.h", + "src/core/iomgr/pollset_set.h", + "src/core/iomgr/pollset_set_posix.h", + "src/core/iomgr/pollset_set_windows.h", + "src/core/iomgr/pollset_windows.h", + "src/core/iomgr/resolve_address.h", + "src/core/iomgr/sockaddr.h", + "src/core/iomgr/sockaddr_posix.h", + "src/core/iomgr/sockaddr_utils.h", + "src/core/iomgr/sockaddr_win32.h", + "src/core/iomgr/socket_utils_posix.h", + "src/core/iomgr/socket_windows.h", + "src/core/iomgr/tcp_client.h", + "src/core/iomgr/tcp_posix.h", + "src/core/iomgr/tcp_server.h", + "src/core/iomgr/tcp_windows.h", + "src/core/iomgr/time_averaged_stats.h", + "src/core/iomgr/wakeup_fd_pipe.h", + "src/core/iomgr/wakeup_fd_posix.h", + "src/core/json/json.h", + "src/core/json/json_common.h", + "src/core/json/json_reader.h", + "src/core/json/json_writer.h", + "src/core/profiling/timers.h", + "src/core/profiling/timers_preciseclock.h", + "src/core/surface/byte_buffer_queue.h", + "src/core/surface/call.h", + "src/core/surface/channel.h", + "src/core/surface/client.h", + "src/core/surface/completion_queue.h", + "src/core/surface/event_string.h", + "src/core/surface/init.h", + "src/core/surface/server.h", + "src/core/surface/surface_trace.h", + "src/core/transport/chttp2/alpn.h", + "src/core/transport/chttp2/bin_encoder.h", + "src/core/transport/chttp2/frame.h", + "src/core/transport/chttp2/frame_data.h", + "src/core/transport/chttp2/frame_goaway.h", + "src/core/transport/chttp2/frame_ping.h", + "src/core/transport/chttp2/frame_rst_stream.h", + "src/core/transport/chttp2/frame_settings.h", + "src/core/transport/chttp2/frame_window_update.h", + "src/core/transport/chttp2/hpack_parser.h", + "src/core/transport/chttp2/hpack_table.h", + "src/core/transport/chttp2/http2_errors.h", + "src/core/transport/chttp2/huffsyms.h", + "src/core/transport/chttp2/status_conversion.h", + "src/core/transport/chttp2/stream_encoder.h", + "src/core/transport/chttp2/stream_map.h", + "src/core/transport/chttp2/timeout_encoding.h", + "src/core/transport/chttp2/varint.h", + "src/core/transport/chttp2_transport.h", + "src/core/transport/metadata.h", + "src/core/transport/stream_op.h", + "src/core/transport/transport.h", + "src/core/transport/transport_impl.h", + "src/core/census/context.h" + ], + "language": "c", + "name": "grpc", + "src": [ + "src/core/httpcli/format_request.c", + "src/core/httpcli/httpcli.c", + "src/core/httpcli/httpcli_security_connector.c", + "src/core/httpcli/parser.c", + "src/core/security/base64.c", + "src/core/security/client_auth_filter.c", + "src/core/security/credentials.c", + "src/core/security/credentials_metadata.c", + "src/core/security/credentials_posix.c", + "src/core/security/credentials_win32.c", + "src/core/security/google_default_credentials.c", + "src/core/security/json_token.c", + "src/core/security/secure_endpoint.c", + "src/core/security/secure_transport_setup.c", + "src/core/security/security_connector.c", + "src/core/security/security_context.c", + "src/core/security/server_auth_filter.c", + "src/core/security/server_secure_chttp2.c", + "src/core/surface/init_secure.c", + "src/core/surface/secure_channel_create.c", + "src/core/tsi/fake_transport_security.c", + "src/core/tsi/ssl_transport_security.c", + "src/core/tsi/transport_security.c", + "src/core/census/grpc_context.c", + "src/core/channel/channel_args.c", + "src/core/channel/channel_stack.c", + "src/core/channel/child_channel.c", + "src/core/channel/client_channel.c", + "src/core/channel/client_setup.c", + "src/core/channel/connected_channel.c", + "src/core/channel/http_client_filter.c", + "src/core/channel/http_server_filter.c", + "src/core/channel/noop_filter.c", + "src/core/compression/algorithm.c", + "src/core/compression/message_compress.c", + "src/core/debug/trace.c", + "src/core/iomgr/alarm.c", + "src/core/iomgr/alarm_heap.c", + "src/core/iomgr/endpoint.c", + "src/core/iomgr/endpoint_pair_posix.c", + "src/core/iomgr/endpoint_pair_windows.c", + "src/core/iomgr/fd_posix.c", + "src/core/iomgr/iocp_windows.c", + "src/core/iomgr/iomgr.c", + "src/core/iomgr/iomgr_posix.c", + "src/core/iomgr/iomgr_windows.c", + "src/core/iomgr/pollset_kick_posix.c", + "src/core/iomgr/pollset_multipoller_with_epoll.c", + "src/core/iomgr/pollset_multipoller_with_poll_posix.c", + "src/core/iomgr/pollset_posix.c", + "src/core/iomgr/pollset_set_posix.c", + "src/core/iomgr/pollset_set_windows.c", + "src/core/iomgr/pollset_windows.c", + "src/core/iomgr/resolve_address_posix.c", + "src/core/iomgr/resolve_address_windows.c", + "src/core/iomgr/sockaddr_utils.c", + "src/core/iomgr/socket_utils_common_posix.c", + "src/core/iomgr/socket_utils_linux.c", + "src/core/iomgr/socket_utils_posix.c", + "src/core/iomgr/socket_windows.c", + "src/core/iomgr/tcp_client_posix.c", + "src/core/iomgr/tcp_client_windows.c", + "src/core/iomgr/tcp_posix.c", + "src/core/iomgr/tcp_server_posix.c", + "src/core/iomgr/tcp_server_windows.c", + "src/core/iomgr/tcp_windows.c", + "src/core/iomgr/time_averaged_stats.c", + "src/core/iomgr/wakeup_fd_eventfd.c", + "src/core/iomgr/wakeup_fd_nospecial.c", + "src/core/iomgr/wakeup_fd_pipe.c", + "src/core/iomgr/wakeup_fd_posix.c", + "src/core/json/json.c", + "src/core/json/json_reader.c", + "src/core/json/json_string.c", + "src/core/json/json_writer.c", + "src/core/profiling/basic_timers.c", + "src/core/profiling/stap_timers.c", + "src/core/surface/byte_buffer.c", + "src/core/surface/byte_buffer_queue.c", + "src/core/surface/byte_buffer_reader.c", + "src/core/surface/call.c", + "src/core/surface/call_details.c", + "src/core/surface/call_log_batch.c", + "src/core/surface/channel.c", + "src/core/surface/channel_create.c", + "src/core/surface/client.c", + "src/core/surface/completion_queue.c", + "src/core/surface/event_string.c", + "src/core/surface/init.c", + "src/core/surface/lame_client.c", + "src/core/surface/metadata_array.c", + "src/core/surface/server.c", + "src/core/surface/server_chttp2.c", + "src/core/surface/server_create.c", + "src/core/surface/surface_trace.c", + "src/core/transport/chttp2/alpn.c", + "src/core/transport/chttp2/bin_encoder.c", + "src/core/transport/chttp2/frame_data.c", + "src/core/transport/chttp2/frame_goaway.c", + "src/core/transport/chttp2/frame_ping.c", + "src/core/transport/chttp2/frame_rst_stream.c", + "src/core/transport/chttp2/frame_settings.c", + "src/core/transport/chttp2/frame_window_update.c", + "src/core/transport/chttp2/hpack_parser.c", + "src/core/transport/chttp2/hpack_table.c", + "src/core/transport/chttp2/huffsyms.c", + "src/core/transport/chttp2/status_conversion.c", + "src/core/transport/chttp2/stream_encoder.c", + "src/core/transport/chttp2/stream_map.c", + "src/core/transport/chttp2/timeout_encoding.c", + "src/core/transport/chttp2/varint.c", + "src/core/transport/chttp2_transport.c", + "src/core/transport/metadata.c", + "src/core/transport/stream_op.c", + "src/core/transport/transport.c", + "src/core/transport/transport_op_string.c", + "src/core/census/context.c", + "src/core/census/initialize.c", + "include/grpc/grpc_security.h", + "include/grpc/byte_buffer.h", + "include/grpc/byte_buffer_reader.h", + "include/grpc/compression.h", + "include/grpc/grpc.h", + "include/grpc/status.h", + "include/grpc/census.h", + "src/core/httpcli/format_request.h", + "src/core/httpcli/httpcli.h", + "src/core/httpcli/httpcli_security_connector.h", + "src/core/httpcli/parser.h", + "src/core/security/auth_filters.h", + "src/core/security/base64.h", + "src/core/security/credentials.h", + "src/core/security/json_token.h", + "src/core/security/secure_endpoint.h", + "src/core/security/secure_transport_setup.h", + "src/core/security/security_connector.h", + "src/core/security/security_context.h", + "src/core/tsi/fake_transport_security.h", + "src/core/tsi/ssl_transport_security.h", + "src/core/tsi/transport_security.h", + "src/core/tsi/transport_security_interface.h", + "src/core/census/grpc_context.h", + "src/core/channel/census_filter.h", + "src/core/channel/channel_args.h", + "src/core/channel/channel_stack.h", + "src/core/channel/child_channel.h", + "src/core/channel/client_channel.h", + "src/core/channel/client_setup.h", + "src/core/channel/connected_channel.h", + "src/core/channel/context.h", + "src/core/channel/http_client_filter.h", + "src/core/channel/http_server_filter.h", + "src/core/channel/noop_filter.h", + "src/core/compression/message_compress.h", + "src/core/debug/trace.h", + "src/core/iomgr/alarm.h", + "src/core/iomgr/alarm_heap.h", + "src/core/iomgr/alarm_internal.h", + "src/core/iomgr/endpoint.h", + "src/core/iomgr/endpoint_pair.h", + "src/core/iomgr/fd_posix.h", + "src/core/iomgr/iocp_windows.h", + "src/core/iomgr/iomgr.h", + "src/core/iomgr/iomgr_internal.h", + "src/core/iomgr/iomgr_posix.h", + "src/core/iomgr/pollset.h", + "src/core/iomgr/pollset_kick_posix.h", + "src/core/iomgr/pollset_posix.h", + "src/core/iomgr/pollset_set.h", + "src/core/iomgr/pollset_set_posix.h", + "src/core/iomgr/pollset_set_windows.h", + "src/core/iomgr/pollset_windows.h", + "src/core/iomgr/resolve_address.h", + "src/core/iomgr/sockaddr.h", + "src/core/iomgr/sockaddr_posix.h", + "src/core/iomgr/sockaddr_utils.h", + "src/core/iomgr/sockaddr_win32.h", + "src/core/iomgr/socket_utils_posix.h", + "src/core/iomgr/socket_windows.h", + "src/core/iomgr/tcp_client.h", + "src/core/iomgr/tcp_posix.h", + "src/core/iomgr/tcp_server.h", + "src/core/iomgr/tcp_windows.h", + "src/core/iomgr/time_averaged_stats.h", + "src/core/iomgr/wakeup_fd_pipe.h", + "src/core/iomgr/wakeup_fd_posix.h", + "src/core/json/json.h", + "src/core/json/json_common.h", + "src/core/json/json_reader.h", + "src/core/json/json_writer.h", + "src/core/profiling/timers.h", + "src/core/profiling/timers_preciseclock.h", + "src/core/surface/byte_buffer_queue.h", + "src/core/surface/call.h", + "src/core/surface/channel.h", + "src/core/surface/client.h", + "src/core/surface/completion_queue.h", + "src/core/surface/event_string.h", + "src/core/surface/init.h", + "src/core/surface/server.h", + "src/core/surface/surface_trace.h", + "src/core/transport/chttp2/alpn.h", + "src/core/transport/chttp2/bin_encoder.h", + "src/core/transport/chttp2/frame.h", + "src/core/transport/chttp2/frame_data.h", + "src/core/transport/chttp2/frame_goaway.h", + "src/core/transport/chttp2/frame_ping.h", + "src/core/transport/chttp2/frame_rst_stream.h", + "src/core/transport/chttp2/frame_settings.h", + "src/core/transport/chttp2/frame_window_update.h", + "src/core/transport/chttp2/hpack_parser.h", + "src/core/transport/chttp2/hpack_table.h", + "src/core/transport/chttp2/http2_errors.h", + "src/core/transport/chttp2/huffsyms.h", + "src/core/transport/chttp2/status_conversion.h", + "src/core/transport/chttp2/stream_encoder.h", + "src/core/transport/chttp2/stream_map.h", + "src/core/transport/chttp2/timeout_encoding.h", + "src/core/transport/chttp2/varint.h", + "src/core/transport/chttp2_transport.h", + "src/core/transport/metadata.h", + "src/core/transport/stream_op.h", + "src/core/transport/transport.h", + "src/core/transport/transport_impl.h", + "src/core/census/context.h" + ] + }, + { + "deps": [ + "gpr", + "gpr_test_util", + "grpc" + ], + "headers": [ + "test/core/end2end/data/ssl_test_data.h", + "test/core/end2end/cq_verifier.h", + "test/core/iomgr/endpoint_tests.h", + "test/core/util/grpc_profiler.h", + "test/core/util/parse_hexstring.h", + "test/core/util/port.h", + "test/core/util/slice_splitter.h" + ], + "language": "c", + "name": "grpc_test_util", + "src": [ + "test/core/end2end/data/server1_cert.c", + "test/core/end2end/data/server1_key.c", + "test/core/end2end/data/test_root_cert.c", + "test/core/end2end/cq_verifier.c", + "test/core/iomgr/endpoint_tests.c", + "test/core/util/grpc_profiler.c", + "test/core/util/parse_hexstring.c", + "test/core/util/port_posix.c", + "test/core/util/port_windows.c", + "test/core/util/slice_splitter.c", + "test/core/end2end/data/ssl_test_data.h", + "test/core/end2end/cq_verifier.h", + "test/core/iomgr/endpoint_tests.h", + "test/core/util/grpc_profiler.h", + "test/core/util/parse_hexstring.h", + "test/core/util/port.h", + "test/core/util/slice_splitter.h" + ] + }, + { + "deps": [ + "gpr", + "gpr_test_util", + "grpc" + ], + "headers": [ + "test/core/end2end/cq_verifier.h", + "test/core/iomgr/endpoint_tests.h", + "test/core/util/grpc_profiler.h", + "test/core/util/parse_hexstring.h", + "test/core/util/port.h", + "test/core/util/slice_splitter.h" + ], + "language": "c", + "name": "grpc_test_util_unsecure", + "src": [ + "test/core/end2end/cq_verifier.c", + "test/core/iomgr/endpoint_tests.c", + "test/core/util/grpc_profiler.c", + "test/core/util/parse_hexstring.c", + "test/core/util/port_posix.c", + "test/core/util/port_windows.c", + "test/core/util/slice_splitter.c", + "test/core/end2end/cq_verifier.h", + "test/core/iomgr/endpoint_tests.h", + "test/core/util/grpc_profiler.h", + "test/core/util/parse_hexstring.h", + "test/core/util/port.h", + "test/core/util/slice_splitter.h" + ] + }, + { + "deps": [ + "gpr" + ], + "headers": [ + "include/grpc/byte_buffer.h", + "include/grpc/byte_buffer_reader.h", + "include/grpc/compression.h", + "include/grpc/grpc.h", + "include/grpc/status.h", + "include/grpc/census.h", + "src/core/census/grpc_context.h", + "src/core/channel/census_filter.h", + "src/core/channel/channel_args.h", + "src/core/channel/channel_stack.h", + "src/core/channel/child_channel.h", + "src/core/channel/client_channel.h", + "src/core/channel/client_setup.h", + "src/core/channel/connected_channel.h", + "src/core/channel/context.h", + "src/core/channel/http_client_filter.h", + "src/core/channel/http_server_filter.h", + "src/core/channel/noop_filter.h", + "src/core/compression/message_compress.h", + "src/core/debug/trace.h", + "src/core/iomgr/alarm.h", + "src/core/iomgr/alarm_heap.h", + "src/core/iomgr/alarm_internal.h", + "src/core/iomgr/endpoint.h", + "src/core/iomgr/endpoint_pair.h", + "src/core/iomgr/fd_posix.h", + "src/core/iomgr/iocp_windows.h", + "src/core/iomgr/iomgr.h", + "src/core/iomgr/iomgr_internal.h", + "src/core/iomgr/iomgr_posix.h", + "src/core/iomgr/pollset.h", + "src/core/iomgr/pollset_kick_posix.h", + "src/core/iomgr/pollset_posix.h", + "src/core/iomgr/pollset_set.h", + "src/core/iomgr/pollset_set_posix.h", + "src/core/iomgr/pollset_set_windows.h", + "src/core/iomgr/pollset_windows.h", + "src/core/iomgr/resolve_address.h", + "src/core/iomgr/sockaddr.h", + "src/core/iomgr/sockaddr_posix.h", + "src/core/iomgr/sockaddr_utils.h", + "src/core/iomgr/sockaddr_win32.h", + "src/core/iomgr/socket_utils_posix.h", + "src/core/iomgr/socket_windows.h", + "src/core/iomgr/tcp_client.h", + "src/core/iomgr/tcp_posix.h", + "src/core/iomgr/tcp_server.h", + "src/core/iomgr/tcp_windows.h", + "src/core/iomgr/time_averaged_stats.h", + "src/core/iomgr/wakeup_fd_pipe.h", + "src/core/iomgr/wakeup_fd_posix.h", + "src/core/json/json.h", + "src/core/json/json_common.h", + "src/core/json/json_reader.h", + "src/core/json/json_writer.h", + "src/core/profiling/timers.h", + "src/core/profiling/timers_preciseclock.h", + "src/core/surface/byte_buffer_queue.h", + "src/core/surface/call.h", + "src/core/surface/channel.h", + "src/core/surface/client.h", + "src/core/surface/completion_queue.h", + "src/core/surface/event_string.h", + "src/core/surface/init.h", + "src/core/surface/server.h", + "src/core/surface/surface_trace.h", + "src/core/transport/chttp2/alpn.h", + "src/core/transport/chttp2/bin_encoder.h", + "src/core/transport/chttp2/frame.h", + "src/core/transport/chttp2/frame_data.h", + "src/core/transport/chttp2/frame_goaway.h", + "src/core/transport/chttp2/frame_ping.h", + "src/core/transport/chttp2/frame_rst_stream.h", + "src/core/transport/chttp2/frame_settings.h", + "src/core/transport/chttp2/frame_window_update.h", + "src/core/transport/chttp2/hpack_parser.h", + "src/core/transport/chttp2/hpack_table.h", + "src/core/transport/chttp2/http2_errors.h", + "src/core/transport/chttp2/huffsyms.h", + "src/core/transport/chttp2/status_conversion.h", + "src/core/transport/chttp2/stream_encoder.h", + "src/core/transport/chttp2/stream_map.h", + "src/core/transport/chttp2/timeout_encoding.h", + "src/core/transport/chttp2/varint.h", + "src/core/transport/chttp2_transport.h", + "src/core/transport/metadata.h", + "src/core/transport/stream_op.h", + "src/core/transport/transport.h", + "src/core/transport/transport_impl.h", + "src/core/census/context.h" + ], + "language": "c", + "name": "grpc_unsecure", + "src": [ + "src/core/surface/init_unsecure.c", + "src/core/census/grpc_context.c", + "src/core/channel/channel_args.c", + "src/core/channel/channel_stack.c", + "src/core/channel/child_channel.c", + "src/core/channel/client_channel.c", + "src/core/channel/client_setup.c", + "src/core/channel/connected_channel.c", + "src/core/channel/http_client_filter.c", + "src/core/channel/http_server_filter.c", + "src/core/channel/noop_filter.c", + "src/core/compression/algorithm.c", + "src/core/compression/message_compress.c", + "src/core/debug/trace.c", + "src/core/iomgr/alarm.c", + "src/core/iomgr/alarm_heap.c", + "src/core/iomgr/endpoint.c", + "src/core/iomgr/endpoint_pair_posix.c", + "src/core/iomgr/endpoint_pair_windows.c", + "src/core/iomgr/fd_posix.c", + "src/core/iomgr/iocp_windows.c", + "src/core/iomgr/iomgr.c", + "src/core/iomgr/iomgr_posix.c", + "src/core/iomgr/iomgr_windows.c", + "src/core/iomgr/pollset_kick_posix.c", + "src/core/iomgr/pollset_multipoller_with_epoll.c", + "src/core/iomgr/pollset_multipoller_with_poll_posix.c", + "src/core/iomgr/pollset_posix.c", + "src/core/iomgr/pollset_set_posix.c", + "src/core/iomgr/pollset_set_windows.c", + "src/core/iomgr/pollset_windows.c", + "src/core/iomgr/resolve_address_posix.c", + "src/core/iomgr/resolve_address_windows.c", + "src/core/iomgr/sockaddr_utils.c", + "src/core/iomgr/socket_utils_common_posix.c", + "src/core/iomgr/socket_utils_linux.c", + "src/core/iomgr/socket_utils_posix.c", + "src/core/iomgr/socket_windows.c", + "src/core/iomgr/tcp_client_posix.c", + "src/core/iomgr/tcp_client_windows.c", + "src/core/iomgr/tcp_posix.c", + "src/core/iomgr/tcp_server_posix.c", + "src/core/iomgr/tcp_server_windows.c", + "src/core/iomgr/tcp_windows.c", + "src/core/iomgr/time_averaged_stats.c", + "src/core/iomgr/wakeup_fd_eventfd.c", + "src/core/iomgr/wakeup_fd_nospecial.c", + "src/core/iomgr/wakeup_fd_pipe.c", + "src/core/iomgr/wakeup_fd_posix.c", + "src/core/json/json.c", + "src/core/json/json_reader.c", + "src/core/json/json_string.c", + "src/core/json/json_writer.c", + "src/core/profiling/basic_timers.c", + "src/core/profiling/stap_timers.c", + "src/core/surface/byte_buffer.c", + "src/core/surface/byte_buffer_queue.c", + "src/core/surface/byte_buffer_reader.c", + "src/core/surface/call.c", + "src/core/surface/call_details.c", + "src/core/surface/call_log_batch.c", + "src/core/surface/channel.c", + "src/core/surface/channel_create.c", + "src/core/surface/client.c", + "src/core/surface/completion_queue.c", + "src/core/surface/event_string.c", + "src/core/surface/init.c", + "src/core/surface/lame_client.c", + "src/core/surface/metadata_array.c", + "src/core/surface/server.c", + "src/core/surface/server_chttp2.c", + "src/core/surface/server_create.c", + "src/core/surface/surface_trace.c", + "src/core/transport/chttp2/alpn.c", + "src/core/transport/chttp2/bin_encoder.c", + "src/core/transport/chttp2/frame_data.c", + "src/core/transport/chttp2/frame_goaway.c", + "src/core/transport/chttp2/frame_ping.c", + "src/core/transport/chttp2/frame_rst_stream.c", + "src/core/transport/chttp2/frame_settings.c", + "src/core/transport/chttp2/frame_window_update.c", + "src/core/transport/chttp2/hpack_parser.c", + "src/core/transport/chttp2/hpack_table.c", + "src/core/transport/chttp2/huffsyms.c", + "src/core/transport/chttp2/status_conversion.c", + "src/core/transport/chttp2/stream_encoder.c", + "src/core/transport/chttp2/stream_map.c", + "src/core/transport/chttp2/timeout_encoding.c", + "src/core/transport/chttp2/varint.c", + "src/core/transport/chttp2_transport.c", + "src/core/transport/metadata.c", + "src/core/transport/stream_op.c", + "src/core/transport/transport.c", + "src/core/transport/transport_op_string.c", + "src/core/census/context.c", + "src/core/census/initialize.c", + "include/grpc/byte_buffer.h", + "include/grpc/byte_buffer_reader.h", + "include/grpc/compression.h", + "include/grpc/grpc.h", + "include/grpc/status.h", + "include/grpc/census.h", + "src/core/census/grpc_context.h", + "src/core/channel/census_filter.h", + "src/core/channel/channel_args.h", + "src/core/channel/channel_stack.h", + "src/core/channel/child_channel.h", + "src/core/channel/client_channel.h", + "src/core/channel/client_setup.h", + "src/core/channel/connected_channel.h", + "src/core/channel/context.h", + "src/core/channel/http_client_filter.h", + "src/core/channel/http_server_filter.h", + "src/core/channel/noop_filter.h", + "src/core/compression/message_compress.h", + "src/core/debug/trace.h", + "src/core/iomgr/alarm.h", + "src/core/iomgr/alarm_heap.h", + "src/core/iomgr/alarm_internal.h", + "src/core/iomgr/endpoint.h", + "src/core/iomgr/endpoint_pair.h", + "src/core/iomgr/fd_posix.h", + "src/core/iomgr/iocp_windows.h", + "src/core/iomgr/iomgr.h", + "src/core/iomgr/iomgr_internal.h", + "src/core/iomgr/iomgr_posix.h", + "src/core/iomgr/pollset.h", + "src/core/iomgr/pollset_kick_posix.h", + "src/core/iomgr/pollset_posix.h", + "src/core/iomgr/pollset_set.h", + "src/core/iomgr/pollset_set_posix.h", + "src/core/iomgr/pollset_set_windows.h", + "src/core/iomgr/pollset_windows.h", + "src/core/iomgr/resolve_address.h", + "src/core/iomgr/sockaddr.h", + "src/core/iomgr/sockaddr_posix.h", + "src/core/iomgr/sockaddr_utils.h", + "src/core/iomgr/sockaddr_win32.h", + "src/core/iomgr/socket_utils_posix.h", + "src/core/iomgr/socket_windows.h", + "src/core/iomgr/tcp_client.h", + "src/core/iomgr/tcp_posix.h", + "src/core/iomgr/tcp_server.h", + "src/core/iomgr/tcp_windows.h", + "src/core/iomgr/time_averaged_stats.h", + "src/core/iomgr/wakeup_fd_pipe.h", + "src/core/iomgr/wakeup_fd_posix.h", + "src/core/json/json.h", + "src/core/json/json_common.h", + "src/core/json/json_reader.h", + "src/core/json/json_writer.h", + "src/core/profiling/timers.h", + "src/core/profiling/timers_preciseclock.h", + "src/core/surface/byte_buffer_queue.h", + "src/core/surface/call.h", + "src/core/surface/channel.h", + "src/core/surface/client.h", + "src/core/surface/completion_queue.h", + "src/core/surface/event_string.h", + "src/core/surface/init.h", + "src/core/surface/server.h", + "src/core/surface/surface_trace.h", + "src/core/transport/chttp2/alpn.h", + "src/core/transport/chttp2/bin_encoder.h", + "src/core/transport/chttp2/frame.h", + "src/core/transport/chttp2/frame_data.h", + "src/core/transport/chttp2/frame_goaway.h", + "src/core/transport/chttp2/frame_ping.h", + "src/core/transport/chttp2/frame_rst_stream.h", + "src/core/transport/chttp2/frame_settings.h", + "src/core/transport/chttp2/frame_window_update.h", + "src/core/transport/chttp2/hpack_parser.h", + "src/core/transport/chttp2/hpack_table.h", + "src/core/transport/chttp2/http2_errors.h", + "src/core/transport/chttp2/huffsyms.h", + "src/core/transport/chttp2/status_conversion.h", + "src/core/transport/chttp2/stream_encoder.h", + "src/core/transport/chttp2/stream_map.h", + "src/core/transport/chttp2/timeout_encoding.h", + "src/core/transport/chttp2/varint.h", + "src/core/transport/chttp2_transport.h", + "src/core/transport/metadata.h", + "src/core/transport/stream_op.h", + "src/core/transport/transport.h", + "src/core/transport/transport_impl.h", + "src/core/census/context.h" + ] + }, + { + "deps": [ + "gpr", + "grpc" + ], + "headers": [ + "include/grpc++/async_generic_service.h", + "include/grpc++/async_unary_call.h", + "include/grpc++/byte_buffer.h", + "include/grpc++/channel_arguments.h", + "include/grpc++/channel_interface.h", + "include/grpc++/client_context.h", + "include/grpc++/completion_queue.h", + "include/grpc++/config.h", + "include/grpc++/config_protobuf.h", + "include/grpc++/create_channel.h", + "include/grpc++/credentials.h", + "include/grpc++/generic_stub.h", + "include/grpc++/impl/call.h", + "include/grpc++/impl/client_unary_call.h", + "include/grpc++/impl/grpc_library.h", + "include/grpc++/impl/internal_stub.h", + "include/grpc++/impl/proto_utils.h", + "include/grpc++/impl/rpc_method.h", + "include/grpc++/impl/rpc_service_method.h", + "include/grpc++/impl/serialization_traits.h", + "include/grpc++/impl/service_type.h", + "include/grpc++/impl/sync.h", + "include/grpc++/impl/sync_cxx11.h", + "include/grpc++/impl/sync_no_cxx11.h", + "include/grpc++/impl/thd.h", + "include/grpc++/impl/thd_cxx11.h", + "include/grpc++/impl/thd_no_cxx11.h", + "include/grpc++/server.h", + "include/grpc++/server_builder.h", + "include/grpc++/server_context.h", + "include/grpc++/server_credentials.h", + "include/grpc++/slice.h", + "include/grpc++/status.h", + "include/grpc++/status_code_enum.h", + "include/grpc++/stream.h", + "include/grpc++/thread_pool_interface.h", + "include/grpc++/time.h", + "src/cpp/client/secure_credentials.h", + "src/cpp/server/secure_server_credentials.h", + "src/cpp/client/channel.h", + "src/cpp/server/thread_pool.h" + ], + "language": "c++", + "name": "grpc++", + "src": [ + "src/cpp/client/secure_channel_arguments.cc", + "src/cpp/client/secure_credentials.cc", + "src/cpp/server/secure_server_credentials.cc", + "src/cpp/client/channel.cc", + "src/cpp/client/channel_arguments.cc", + "src/cpp/client/client_context.cc", + "src/cpp/client/create_channel.cc", + "src/cpp/client/credentials.cc", + "src/cpp/client/generic_stub.cc", + "src/cpp/client/insecure_credentials.cc", + "src/cpp/client/internal_stub.cc", + "src/cpp/common/call.cc", + "src/cpp/common/completion_queue.cc", + "src/cpp/common/rpc_method.cc", + "src/cpp/proto/proto_utils.cc", + "src/cpp/server/async_generic_service.cc", + "src/cpp/server/create_default_thread_pool.cc", + "src/cpp/server/insecure_server_credentials.cc", + "src/cpp/server/server.cc", + "src/cpp/server/server_builder.cc", + "src/cpp/server/server_context.cc", + "src/cpp/server/server_credentials.cc", + "src/cpp/server/thread_pool.cc", + "src/cpp/util/byte_buffer.cc", + "src/cpp/util/slice.cc", + "src/cpp/util/status.cc", + "src/cpp/util/time.cc", + "include/grpc++/async_generic_service.h", + "include/grpc++/async_unary_call.h", + "include/grpc++/byte_buffer.h", + "include/grpc++/channel_arguments.h", + "include/grpc++/channel_interface.h", + "include/grpc++/client_context.h", + "include/grpc++/completion_queue.h", + "include/grpc++/config.h", + "include/grpc++/config_protobuf.h", + "include/grpc++/create_channel.h", + "include/grpc++/credentials.h", + "include/grpc++/generic_stub.h", + "include/grpc++/impl/call.h", + "include/grpc++/impl/client_unary_call.h", + "include/grpc++/impl/grpc_library.h", + "include/grpc++/impl/internal_stub.h", + "include/grpc++/impl/proto_utils.h", + "include/grpc++/impl/rpc_method.h", + "include/grpc++/impl/rpc_service_method.h", + "include/grpc++/impl/serialization_traits.h", + "include/grpc++/impl/service_type.h", + "include/grpc++/impl/sync.h", + "include/grpc++/impl/sync_cxx11.h", + "include/grpc++/impl/sync_no_cxx11.h", + "include/grpc++/impl/thd.h", + "include/grpc++/impl/thd_cxx11.h", + "include/grpc++/impl/thd_no_cxx11.h", + "include/grpc++/server.h", + "include/grpc++/server_builder.h", + "include/grpc++/server_context.h", + "include/grpc++/server_credentials.h", + "include/grpc++/slice.h", + "include/grpc++/status.h", + "include/grpc++/status_code_enum.h", + "include/grpc++/stream.h", + "include/grpc++/thread_pool_interface.h", + "include/grpc++/time.h", + "src/cpp/client/secure_credentials.h", + "src/cpp/server/secure_server_credentials.h", + "src/cpp/client/channel.h", + "src/cpp/server/thread_pool.h" + ] + }, + { + "deps": [], + "headers": [ + "test/cpp/util/test_config.h" + ], + "language": "c++", + "name": "grpc++_test_config", + "src": [ + "test/cpp/util/test_config.cc", + "test/cpp/util/test_config.h" + ] + }, + { + "deps": [ + "grpc++", + "grpc_test_util" + ], + "headers": [ + "test/cpp/util/cli_call.h", + "test/cpp/util/create_test_channel.h", + "test/cpp/util/fake_credentials.h", + "test/cpp/util/subprocess.h", + "test/cpp/util/messages.grpc.pb.h", + "test/cpp/util/messages.pb.h", + "test/cpp/util/echo.grpc.pb.h", + "test/cpp/util/echo.pb.h", + "test/cpp/util/echo_duplicate.grpc.pb.h", + "test/cpp/util/echo_duplicate.pb.h" + ], + "language": "c++", + "name": "grpc++_test_util", + "src": [ + "test/cpp/util/cli_call.cc", + "test/cpp/util/create_test_channel.cc", + "test/cpp/util/fake_credentials.cc", + "test/cpp/util/subprocess.cc", + "test/cpp/util/cli_call.h", + "test/cpp/util/create_test_channel.h", + "test/cpp/util/fake_credentials.h", + "test/cpp/util/subprocess.h" + ] + }, + { + "deps": [ + "gpr", + "grpc_unsecure" + ], + "headers": [ + "include/grpc++/async_generic_service.h", + "include/grpc++/async_unary_call.h", + "include/grpc++/byte_buffer.h", + "include/grpc++/channel_arguments.h", + "include/grpc++/channel_interface.h", + "include/grpc++/client_context.h", + "include/grpc++/completion_queue.h", + "include/grpc++/config.h", + "include/grpc++/config_protobuf.h", + "include/grpc++/create_channel.h", + "include/grpc++/credentials.h", + "include/grpc++/generic_stub.h", + "include/grpc++/impl/call.h", + "include/grpc++/impl/client_unary_call.h", + "include/grpc++/impl/grpc_library.h", + "include/grpc++/impl/internal_stub.h", + "include/grpc++/impl/proto_utils.h", + "include/grpc++/impl/rpc_method.h", + "include/grpc++/impl/rpc_service_method.h", + "include/grpc++/impl/serialization_traits.h", + "include/grpc++/impl/service_type.h", + "include/grpc++/impl/sync.h", + "include/grpc++/impl/sync_cxx11.h", + "include/grpc++/impl/sync_no_cxx11.h", + "include/grpc++/impl/thd.h", + "include/grpc++/impl/thd_cxx11.h", + "include/grpc++/impl/thd_no_cxx11.h", + "include/grpc++/server.h", + "include/grpc++/server_builder.h", + "include/grpc++/server_context.h", + "include/grpc++/server_credentials.h", + "include/grpc++/slice.h", + "include/grpc++/status.h", + "include/grpc++/status_code_enum.h", + "include/grpc++/stream.h", + "include/grpc++/thread_pool_interface.h", + "include/grpc++/time.h", + "src/cpp/client/channel.h", + "src/cpp/server/thread_pool.h" + ], + "language": "c++", + "name": "grpc++_unsecure", + "src": [ + "src/cpp/client/channel.cc", + "src/cpp/client/channel_arguments.cc", + "src/cpp/client/client_context.cc", + "src/cpp/client/create_channel.cc", + "src/cpp/client/credentials.cc", + "src/cpp/client/generic_stub.cc", + "src/cpp/client/insecure_credentials.cc", + "src/cpp/client/internal_stub.cc", + "src/cpp/common/call.cc", + "src/cpp/common/completion_queue.cc", + "src/cpp/common/rpc_method.cc", + "src/cpp/proto/proto_utils.cc", + "src/cpp/server/async_generic_service.cc", + "src/cpp/server/create_default_thread_pool.cc", + "src/cpp/server/insecure_server_credentials.cc", + "src/cpp/server/server.cc", + "src/cpp/server/server_builder.cc", + "src/cpp/server/server_context.cc", + "src/cpp/server/server_credentials.cc", + "src/cpp/server/thread_pool.cc", + "src/cpp/util/byte_buffer.cc", + "src/cpp/util/slice.cc", + "src/cpp/util/status.cc", + "src/cpp/util/time.cc", + "include/grpc++/async_generic_service.h", + "include/grpc++/async_unary_call.h", + "include/grpc++/byte_buffer.h", + "include/grpc++/channel_arguments.h", + "include/grpc++/channel_interface.h", + "include/grpc++/client_context.h", + "include/grpc++/completion_queue.h", + "include/grpc++/config.h", + "include/grpc++/config_protobuf.h", + "include/grpc++/create_channel.h", + "include/grpc++/credentials.h", + "include/grpc++/generic_stub.h", + "include/grpc++/impl/call.h", + "include/grpc++/impl/client_unary_call.h", + "include/grpc++/impl/grpc_library.h", + "include/grpc++/impl/internal_stub.h", + "include/grpc++/impl/proto_utils.h", + "include/grpc++/impl/rpc_method.h", + "include/grpc++/impl/rpc_service_method.h", + "include/grpc++/impl/serialization_traits.h", + "include/grpc++/impl/service_type.h", + "include/grpc++/impl/sync.h", + "include/grpc++/impl/sync_cxx11.h", + "include/grpc++/impl/sync_no_cxx11.h", + "include/grpc++/impl/thd.h", + "include/grpc++/impl/thd_cxx11.h", + "include/grpc++/impl/thd_no_cxx11.h", + "include/grpc++/server.h", + "include/grpc++/server_builder.h", + "include/grpc++/server_context.h", + "include/grpc++/server_credentials.h", + "include/grpc++/slice.h", + "include/grpc++/status.h", + "include/grpc++/status_code_enum.h", + "include/grpc++/stream.h", + "include/grpc++/thread_pool_interface.h", + "include/grpc++/time.h", + "src/cpp/client/channel.h", + "src/cpp/server/thread_pool.h" + ] + }, + { + "deps": [], + "headers": [ + "include/grpc++/config.h", + "include/grpc++/config_protobuf.h", + "src/compiler/config.h", + "src/compiler/cpp_generator.h", + "src/compiler/cpp_generator_helpers.h", + "src/compiler/csharp_generator.h", + "src/compiler/csharp_generator_helpers.h", + "src/compiler/generator_helpers.h", + "src/compiler/objective_c_generator.h", + "src/compiler/objective_c_generator_helpers.h", + "src/compiler/python_generator.h", + "src/compiler/ruby_generator.h", + "src/compiler/ruby_generator_helpers-inl.h", + "src/compiler/ruby_generator_map-inl.h", + "src/compiler/ruby_generator_string-inl.h" + ], + "language": "c++", + "name": "grpc_plugin_support", + "src": [ + "src/compiler/cpp_generator.cc", + "src/compiler/csharp_generator.cc", + "src/compiler/objective_c_generator.cc", + "src/compiler/python_generator.cc", + "src/compiler/ruby_generator.cc", + "include/grpc++/config.h", + "include/grpc++/config_protobuf.h", + "src/compiler/config.h", + "src/compiler/cpp_generator.h", + "src/compiler/cpp_generator_helpers.h", + "src/compiler/csharp_generator.h", + "src/compiler/csharp_generator_helpers.h", + "src/compiler/generator_helpers.h", + "src/compiler/objective_c_generator.h", + "src/compiler/objective_c_generator_helpers.h", + "src/compiler/python_generator.h", + "src/compiler/ruby_generator.h", + "src/compiler/ruby_generator_helpers-inl.h", + "src/compiler/ruby_generator_map-inl.h", + "src/compiler/ruby_generator_string-inl.h" + ] + }, + { + "deps": [ + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr" + ], + "headers": [ + "test/cpp/interop/client_helper.h" + ], + "language": "c++", + "name": "interop_client_helper", + "src": [ + "test/cpp/interop/client_helper.cc", + "test/cpp/interop/client_helper.h" + ] + }, + { + "deps": [ + "interop_client_helper", + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr", + "grpc++_test_config" + ], + "headers": [ + "test/cpp/interop/interop_client.h", + "test/proto/empty.grpc.pb.h", + "test/proto/empty.pb.h", + "test/proto/messages.grpc.pb.h", + "test/proto/messages.pb.h", + "test/proto/test.grpc.pb.h", + "test/proto/test.pb.h" + ], + "language": "c++", + "name": "interop_client_main", + "src": [ + "test/cpp/interop/client.cc", + "test/cpp/interop/interop_client.cc", + "test/cpp/interop/interop_client.h" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc++", + "grpc", + "gpr" + ], + "headers": [ + "test/cpp/interop/server_helper.h" + ], + "language": "c++", + "name": "interop_server_helper", + "src": [ + "test/cpp/interop/server_helper.cc", + "test/cpp/interop/server_helper.h" + ] + }, + { + "deps": [ + "interop_server_helper", + "grpc++_test_util", + "grpc_test_util", + "grpc++", + "grpc", + "gpr_test_util", + "gpr", + "grpc++_test_config" + ], + "headers": [ + "test/proto/empty.grpc.pb.h", + "test/proto/empty.pb.h", + "test/proto/messages.grpc.pb.h", + "test/proto/messages.pb.h", + "test/proto/test.grpc.pb.h", + "test/proto/test.pb.h" + ], + "language": "c++", + "name": "interop_server_main", + "src": [ + "test/cpp/interop/server.cc" + ] + }, + { + "deps": [ + "grpc++", + "grpc", + "gpr" + ], + "headers": [ + "examples/pubsub/publisher.h", + "examples/pubsub/subscriber.h", + "examples/pubsub/label.grpc.pb.h", + "examples/pubsub/label.pb.h", + "examples/pubsub/empty.grpc.pb.h", + "examples/pubsub/empty.pb.h", + "examples/pubsub/pubsub.grpc.pb.h", + "examples/pubsub/pubsub.pb.h" + ], + "language": "c++", + "name": "pubsub_client_lib", + "src": [ + "examples/pubsub/publisher.cc", + "examples/pubsub/subscriber.cc", + "examples/pubsub/publisher.h", + "examples/pubsub/subscriber.h" + ] + }, + { + "deps": [ + "grpc_test_util", + "grpc++_test_util", + "grpc++" + ], + "headers": [ + "test/cpp/qps/client.h", + "test/cpp/qps/driver.h", + "test/cpp/qps/histogram.h", + "test/cpp/qps/interarrival.h", + "test/cpp/qps/qps_worker.h", + "test/cpp/qps/report.h", + "test/cpp/qps/server.h", + "test/cpp/qps/stats.h", + "test/cpp/qps/timer.h", + "test/cpp/util/benchmark_config.h", + "test/cpp/qps/qpstest.grpc.pb.h", + "test/cpp/qps/qpstest.pb.h" + ], + "language": "c++", + "name": "qps", + "src": [ + "test/cpp/qps/client_async.cc", + "test/cpp/qps/client_sync.cc", + "test/cpp/qps/driver.cc", + "test/cpp/qps/qps_worker.cc", + "test/cpp/qps/report.cc", + "test/cpp/qps/server_async.cc", + "test/cpp/qps/server_sync.cc", + "test/cpp/qps/timer.cc", + "test/cpp/util/benchmark_config.cc", + "test/cpp/qps/client.h", + "test/cpp/qps/driver.h", + "test/cpp/qps/histogram.h", + "test/cpp/qps/interarrival.h", + "test/cpp/qps/qps_worker.h", + "test/cpp/qps/report.h", + "test/cpp/qps/server.h", + "test/cpp/qps/stats.h", + "test/cpp/qps/timer.h", + "test/cpp/util/benchmark_config.h" + ] + }, + { + "deps": [ + "gpr", + "grpc" + ], + "headers": [], + "language": "csharp", + "name": "grpc_csharp_ext", + "src": [ + "src/csharp/ext/grpc_csharp_ext.c" + ] + }, + { + "deps": [ + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_fixture_chttp2_fake_security", + "src": [ + "test/core/end2end/fixtures/chttp2_fake_security.c", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_fixture_chttp2_fullstack", + "src": [ + "test/core/end2end/fixtures/chttp2_fullstack.c", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_fixture_chttp2_fullstack_uds_posix", + "src": [ + "test/core/end2end/fixtures/chttp2_fullstack_uds_posix.c", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_fixture_chttp2_fullstack_with_poll", + "src": [ + "test/core/end2end/fixtures/chttp2_fullstack_with_poll.c", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_fixture_chttp2_simple_ssl_fullstack", + "src": [ + "test/core/end2end/fixtures/chttp2_simple_ssl_fullstack.c", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_fixture_chttp2_simple_ssl_fullstack_with_poll", + "src": [ + "test/core/end2end/fixtures/chttp2_simple_ssl_fullstack_with_poll.c", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_fixture_chttp2_simple_ssl_with_oauth2_fullstack", + "src": [ + "test/core/end2end/fixtures/chttp2_simple_ssl_with_oauth2_fullstack.c", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_fixture_chttp2_socket_pair", + "src": [ + "test/core/end2end/fixtures/chttp2_socket_pair.c", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_fixture_chttp2_socket_pair_one_byte_at_a_time", + "src": [ + "test/core/end2end/fixtures/chttp2_socket_pair_one_byte_at_a_time.c", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_fixture_chttp2_socket_pair_with_grpc_trace", + "src": [ + "test/core/end2end/fixtures/chttp2_socket_pair_with_grpc_trace.c", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_bad_hostname", + "src": [ + "test/core/end2end/tests/bad_hostname.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_cancel_after_accept", + "src": [ + "test/core/end2end/tests/cancel_after_accept.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_cancel_after_accept_and_writes_closed", + "src": [ + "test/core/end2end/tests/cancel_after_accept_and_writes_closed.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_cancel_after_invoke", + "src": [ + "test/core/end2end/tests/cancel_after_invoke.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_cancel_before_invoke", + "src": [ + "test/core/end2end/tests/cancel_before_invoke.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_cancel_in_a_vacuum", + "src": [ + "test/core/end2end/tests/cancel_in_a_vacuum.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_census_simple_request", + "src": [ + "test/core/end2end/tests/census_simple_request.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_disappearing_server", + "src": [ + "test/core/end2end/tests/disappearing_server.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_early_server_shutdown_finishes_inflight_calls", + "src": [ + "test/core/end2end/tests/early_server_shutdown_finishes_inflight_calls.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_early_server_shutdown_finishes_tags", + "src": [ + "test/core/end2end/tests/early_server_shutdown_finishes_tags.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_empty_batch", + "src": [ + "test/core/end2end/tests/empty_batch.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_graceful_server_shutdown", + "src": [ + "test/core/end2end/tests/graceful_server_shutdown.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_invoke_large_request", + "src": [ + "test/core/end2end/tests/invoke_large_request.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_max_concurrent_streams", + "src": [ + "test/core/end2end/tests/max_concurrent_streams.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_max_message_length", + "src": [ + "test/core/end2end/tests/max_message_length.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_no_op", + "src": [ + "test/core/end2end/tests/no_op.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_ping_pong_streaming", + "src": [ + "test/core/end2end/tests/ping_pong_streaming.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_registered_call", + "src": [ + "test/core/end2end/tests/registered_call.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_request_response_with_binary_metadata_and_payload", + "src": [ + "test/core/end2end/tests/request_response_with_binary_metadata_and_payload.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_request_response_with_metadata_and_payload", + "src": [ + "test/core/end2end/tests/request_response_with_metadata_and_payload.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_request_response_with_payload", + "src": [ + "test/core/end2end/tests/request_response_with_payload.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "end2end_certs", + "grpc_test_util", + "grpc", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_request_response_with_payload_and_call_creds", + "src": [ + "test/core/end2end/tests/request_response_with_payload_and_call_creds.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_request_response_with_trailing_metadata_and_payload", + "src": [ + "test/core/end2end/tests/request_response_with_trailing_metadata_and_payload.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_request_with_flags", + "src": [ + "test/core/end2end/tests/request_with_flags.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_request_with_large_metadata", + "src": [ + "test/core/end2end/tests/request_with_large_metadata.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_request_with_payload", + "src": [ + "test/core/end2end/tests/request_with_payload.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_server_finishes_request", + "src": [ + "test/core/end2end/tests/server_finishes_request.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_simple_delayed_request", + "src": [ + "test/core/end2end/tests/simple_delayed_request.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_simple_request", + "src": [ + "test/core/end2end/tests/simple_request.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ], + "language": "c", + "name": "end2end_test_simple_request_with_high_initial_sequence_number", + "src": [ + "test/core/end2end/tests/simple_request_with_high_initial_sequence_number.c", + "test/core/end2end/tests/cancel_test_helpers.h", + "test/core/end2end/end2end_tests.h" + ] + }, + { + "deps": [], + "headers": [], + "language": "c", + "name": "end2end_certs", + "src": [ + "test/core/end2end/data/test_root_cert.c", + "test/core/end2end/data/server1_cert.c", + "test/core/end2end/data/server1_key.c" + ] + }, + { + "deps": [ + "grpc_test_util_unsecure", + "grpc_unsecure", + "gpr_test_util", + "gpr" + ], + "headers": [ + "test/core/bad_client/bad_client.h" + ], + "language": "c", + "name": "bad_client_test", + "src": [ + "test/core/bad_client/bad_client.c", + "test/core/bad_client/bad_client.h" + ] + } +] diff --git a/vsprojects/grpc++/grpc++.vcxproj b/vsprojects/grpc++/grpc++.vcxproj index e7afd99189..f69d50ffb8 100644 --- a/vsprojects/grpc++/grpc++.vcxproj +++ b/vsprojects/grpc++/grpc++.vcxproj @@ -191,6 +191,8 @@ + + diff --git a/vsprojects/grpc++/grpc++.vcxproj.filters b/vsprojects/grpc++/grpc++.vcxproj.filters index fb0bcab09d..aa4b50e33f 100644 --- a/vsprojects/grpc++/grpc++.vcxproj.filters +++ b/vsprojects/grpc++/grpc++.vcxproj.filters @@ -1,6 +1,9 @@ + + src\cpp\client + src\cpp\client diff --git a/vsprojects/grpc_plugin_support/grpc_plugin_support.vcxproj b/vsprojects/grpc_plugin_support/grpc_plugin_support.vcxproj index c0188e56e7..4f0e4a6e1d 100644 --- a/vsprojects/grpc_plugin_support/grpc_plugin_support.vcxproj +++ b/vsprojects/grpc_plugin_support/grpc_plugin_support.vcxproj @@ -146,6 +146,8 @@ + + diff --git a/vsprojects/grpc_test_util/grpc_test_util.vcxproj b/vsprojects/grpc_test_util/grpc_test_util.vcxproj index e5288f4d44..f250d0a632 100644 --- a/vsprojects/grpc_test_util/grpc_test_util.vcxproj +++ b/vsprojects/grpc_test_util/grpc_test_util.vcxproj @@ -145,6 +145,15 @@ true + + + + + + + + + -- cgit v1.2.3