From 34a57d0346afe95e11104462c30dc468b0cb0b89 Mon Sep 17 00:00:00 2001 From: Yash Tibrewal Date: Mon, 23 Oct 2017 15:33:21 -0700 Subject: rename all test core files to cc and a lot of C++ style conversions --- test/core/util/mock_endpoint.cc | 138 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 138 insertions(+) create mode 100644 test/core/util/mock_endpoint.cc (limited to 'test/core/util/mock_endpoint.cc') diff --git a/test/core/util/mock_endpoint.cc b/test/core/util/mock_endpoint.cc new file mode 100644 index 0000000000..bd386b2148 --- /dev/null +++ b/test/core/util/mock_endpoint.cc @@ -0,0 +1,138 @@ +/* + * + * Copyright 2016 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +/* With the addition of a libuv endpoint, sockaddr.h now includes uv.h when + using that endpoint. Because of various transitive includes in uv.h, + including windows.h on Windows, uv.h must be included before other system + headers. Therefore, sockaddr.h must always be included first */ +#include "src/core/lib/iomgr/sockaddr.h" + +#include "test/core/util/mock_endpoint.h" + +#include + +#include +#include +#include "src/core/lib/iomgr/sockaddr.h" + +typedef struct grpc_mock_endpoint { + grpc_endpoint base; + gpr_mu mu; + void (*on_write)(grpc_slice slice); + grpc_slice_buffer read_buffer; + grpc_slice_buffer *on_read_out; + grpc_closure *on_read; + grpc_resource_user *resource_user; +} grpc_mock_endpoint; + +static void me_read(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep, + grpc_slice_buffer *slices, grpc_closure *cb) { + grpc_mock_endpoint *m = (grpc_mock_endpoint *)ep; + gpr_mu_lock(&m->mu); + if (m->read_buffer.count > 0) { + grpc_slice_buffer_swap(&m->read_buffer, slices); + GRPC_CLOSURE_SCHED(exec_ctx, cb, GRPC_ERROR_NONE); + } else { + m->on_read = cb; + m->on_read_out = slices; + } + gpr_mu_unlock(&m->mu); +} + +static void me_write(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep, + grpc_slice_buffer *slices, grpc_closure *cb) { + grpc_mock_endpoint *m = (grpc_mock_endpoint *)ep; + for (size_t i = 0; i < slices->count; i++) { + m->on_write(slices->slices[i]); + } + GRPC_CLOSURE_SCHED(exec_ctx, cb, GRPC_ERROR_NONE); +} + +static void me_add_to_pollset(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep, + grpc_pollset *pollset) {} + +static void me_add_to_pollset_set(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep, + grpc_pollset_set *pollset) {} + +static void me_shutdown(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep, + grpc_error *why) { + grpc_mock_endpoint *m = (grpc_mock_endpoint *)ep; + gpr_mu_lock(&m->mu); + if (m->on_read) { + GRPC_CLOSURE_SCHED(exec_ctx, m->on_read, + GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING( + "Endpoint Shutdown", &why, 1)); + m->on_read = NULL; + } + gpr_mu_unlock(&m->mu); + grpc_resource_user_shutdown(exec_ctx, m->resource_user); + GRPC_ERROR_UNREF(why); +} + +static void me_destroy(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep) { + grpc_mock_endpoint *m = (grpc_mock_endpoint *)ep; + grpc_slice_buffer_destroy(&m->read_buffer); + grpc_resource_user_unref(exec_ctx, m->resource_user); + gpr_free(m); +} + +static char *me_get_peer(grpc_endpoint *ep) { + return gpr_strdup("fake:mock_endpoint"); +} + +static grpc_resource_user *me_get_resource_user(grpc_endpoint *ep) { + grpc_mock_endpoint *m = (grpc_mock_endpoint *)ep; + return m->resource_user; +} + +static int me_get_fd(grpc_endpoint *ep) { return -1; } + +static const grpc_endpoint_vtable vtable = { + me_read, me_write, me_add_to_pollset, me_add_to_pollset_set, + me_shutdown, me_destroy, me_get_resource_user, me_get_peer, + me_get_fd, +}; + +grpc_endpoint *grpc_mock_endpoint_create(void (*on_write)(grpc_slice slice), + grpc_resource_quota *resource_quota) { + grpc_mock_endpoint *m = (grpc_mock_endpoint *)gpr_malloc(sizeof(*m)); + m->base.vtable = &vtable; + char *name; + gpr_asprintf(&name, "mock_endpoint_%" PRIxPTR, (intptr_t)m); + m->resource_user = grpc_resource_user_create(resource_quota, name); + gpr_free(name); + grpc_slice_buffer_init(&m->read_buffer); + gpr_mu_init(&m->mu); + m->on_write = on_write; + m->on_read = NULL; + return &m->base; +} + +void grpc_mock_endpoint_put_read(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep, + grpc_slice slice) { + grpc_mock_endpoint *m = (grpc_mock_endpoint *)ep; + gpr_mu_lock(&m->mu); + if (m->on_read != NULL) { + grpc_slice_buffer_add(m->on_read_out, slice); + GRPC_CLOSURE_SCHED(exec_ctx, m->on_read, GRPC_ERROR_NONE); + m->on_read = NULL; + } else { + grpc_slice_buffer_add(&m->read_buffer, slice); + } + gpr_mu_unlock(&m->mu); +} -- cgit v1.2.3