diff options
Diffstat (limited to 'test/core/end2end/cq_verifier.cc')
-rw-r--r-- | test/core/end2end/cq_verifier.cc | 321 |
1 files changed, 321 insertions, 0 deletions
diff --git a/test/core/end2end/cq_verifier.cc b/test/core/end2end/cq_verifier.cc new file mode 100644 index 0000000000..fd5193f42c --- /dev/null +++ b/test/core/end2end/cq_verifier.cc @@ -0,0 +1,321 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include "test/core/end2end/cq_verifier.h" + +#include <stdarg.h> +#include <stdio.h> +#include <string.h> + +#include <grpc/byte_buffer.h> +#include <grpc/byte_buffer_reader.h> +#include <grpc/support/alloc.h> +#include <grpc/support/log.h> +#include <grpc/support/string_util.h> +#include <grpc/support/time.h> +#include <grpc/support/useful.h> +#include "src/core/lib/support/string.h" +#include "src/core/lib/surface/event_string.h" + +#define ROOT_EXPECTATION 1000 + +/* a set of metadata we expect to find on an event */ +typedef struct metadata { + size_t count; + size_t cap; + char** keys; + char** values; +} metadata; + +/* details what we expect to find on a single event - and forms a linked + list to detail other expectations */ +typedef struct expectation { + struct expectation* next; + const char* file; + int line; + grpc_completion_type type; + void* tag; + int success; +} expectation; + +/* the verifier itself */ +struct cq_verifier { + /* bound completion queue */ + grpc_completion_queue* cq; + /* start of expectation list */ + expectation* first_expectation; +}; + +cq_verifier* cq_verifier_create(grpc_completion_queue* cq) { + cq_verifier* v = (cq_verifier*)gpr_malloc(sizeof(cq_verifier)); + v->cq = cq; + v->first_expectation = NULL; + return v; +} + +void cq_verifier_destroy(cq_verifier* v) { + cq_verify(v); + gpr_free(v); +} + +static int has_metadata(const grpc_metadata* md, size_t count, const char* key, + const char* value) { + size_t i; + for (i = 0; i < count; i++) { + if (0 == grpc_slice_str_cmp(md[i].key, key) && + 0 == grpc_slice_str_cmp(md[i].value, value)) { + return 1; + } + } + return 0; +} + +int contains_metadata(grpc_metadata_array* array, const char* key, + const char* value) { + return has_metadata(array->metadata, array->count, key, value); +} + +static int has_metadata_slices(const grpc_metadata* md, size_t count, + grpc_slice key, grpc_slice value) { + size_t i; + for (i = 0; i < count; i++) { + if (grpc_slice_eq(md[i].key, key) && grpc_slice_eq(md[i].value, value)) { + return 1; + } + } + return 0; +} + +int contains_metadata_slices(grpc_metadata_array* array, grpc_slice key, + grpc_slice value) { + return has_metadata_slices(array->metadata, array->count, key, value); +} + +static grpc_slice merge_slices(grpc_slice* slices, size_t nslices) { + size_t i; + size_t len = 0; + uint8_t* cursor; + grpc_slice out; + + for (i = 0; i < nslices; i++) { + len += GRPC_SLICE_LENGTH(slices[i]); + } + + out = grpc_slice_malloc(len); + cursor = GRPC_SLICE_START_PTR(out); + + for (i = 0; i < nslices; i++) { + memcpy(cursor, GRPC_SLICE_START_PTR(slices[i]), + GRPC_SLICE_LENGTH(slices[i])); + cursor += GRPC_SLICE_LENGTH(slices[i]); + } + + return out; +} + +int raw_byte_buffer_eq_slice(grpc_byte_buffer* rbb, grpc_slice b) { + grpc_slice a; + int ok; + + if (!rbb) return 0; + + a = merge_slices(rbb->data.raw.slice_buffer.slices, + rbb->data.raw.slice_buffer.count); + ok = GRPC_SLICE_LENGTH(a) == GRPC_SLICE_LENGTH(b) && + 0 == memcmp(GRPC_SLICE_START_PTR(a), GRPC_SLICE_START_PTR(b), + GRPC_SLICE_LENGTH(a)); + grpc_slice_unref(a); + grpc_slice_unref(b); + return ok; +} + +int byte_buffer_eq_slice(grpc_byte_buffer* bb, grpc_slice b) { + grpc_byte_buffer_reader reader; + grpc_byte_buffer* rbb; + int res; + + GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, bb) && + "Couldn't init byte buffer reader"); + rbb = grpc_raw_byte_buffer_from_reader(&reader); + res = raw_byte_buffer_eq_slice(rbb, b); + grpc_byte_buffer_reader_destroy(&reader); + grpc_byte_buffer_destroy(rbb); + + return res; +} + +int byte_buffer_eq_string(grpc_byte_buffer* bb, const char* str) { + grpc_byte_buffer_reader reader; + grpc_byte_buffer* rbb; + int res; + + GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, bb) && + "Couldn't init byte buffer reader"); + rbb = grpc_raw_byte_buffer_from_reader(&reader); + res = raw_byte_buffer_eq_slice(rbb, grpc_slice_from_copied_string(str)); + grpc_byte_buffer_reader_destroy(&reader); + grpc_byte_buffer_destroy(rbb); + + return res; +} + +static bool is_probably_integer(void* p) { return ((uintptr_t)p) < 1000000; } + +static void expectation_to_strvec(gpr_strvec* buf, expectation* e) { + char* tmp; + + if (is_probably_integer(e->tag)) { + gpr_asprintf(&tmp, "tag(%" PRIdPTR ") ", (intptr_t)e->tag); + } else { + gpr_asprintf(&tmp, "%p ", e->tag); + } + gpr_strvec_add(buf, tmp); + + switch (e->type) { + case GRPC_OP_COMPLETE: + gpr_asprintf(&tmp, "GRPC_OP_COMPLETE success=%d %s:%d", e->success, + e->file, e->line); + gpr_strvec_add(buf, tmp); + break; + case GRPC_QUEUE_TIMEOUT: + case GRPC_QUEUE_SHUTDOWN: + gpr_log(GPR_ERROR, "not implemented"); + abort(); + break; + } +} + +static void expectations_to_strvec(gpr_strvec* buf, cq_verifier* v) { + expectation* e; + + for (e = v->first_expectation; e != NULL; e = e->next) { + expectation_to_strvec(buf, e); + gpr_strvec_add(buf, gpr_strdup("\n")); + } +} + +static void fail_no_event_received(cq_verifier* v) { + gpr_strvec buf; + char* msg; + gpr_strvec_init(&buf); + gpr_strvec_add(&buf, gpr_strdup("no event received, but expected:\n")); + expectations_to_strvec(&buf, v); + msg = gpr_strvec_flatten(&buf, NULL); + gpr_log(GPR_ERROR, "%s", msg); + gpr_strvec_destroy(&buf); + gpr_free(msg); + abort(); +} + +static void verify_matches(expectation* e, grpc_event* ev) { + GPR_ASSERT(e->type == ev->type); + switch (e->type) { + case GRPC_OP_COMPLETE: + if (e->success != ev->success) { + gpr_strvec expected; + gpr_strvec_init(&expected); + expectation_to_strvec(&expected, e); + char* s = gpr_strvec_flatten(&expected, NULL); + gpr_strvec_destroy(&expected); + gpr_log(GPR_ERROR, "actual success does not match expected: %s", s); + gpr_free(s); + abort(); + } + break; + case GRPC_QUEUE_SHUTDOWN: + gpr_log(GPR_ERROR, "premature queue shutdown"); + abort(); + break; + case GRPC_QUEUE_TIMEOUT: + gpr_log(GPR_ERROR, "not implemented"); + abort(); + break; + } +} + +void cq_verify(cq_verifier* v) { + const gpr_timespec deadline = grpc_timeout_seconds_to_deadline(10); + while (v->first_expectation != NULL) { + grpc_event ev = grpc_completion_queue_next(v->cq, deadline, NULL); + if (ev.type == GRPC_QUEUE_TIMEOUT) { + fail_no_event_received(v); + break; + } + expectation* e; + expectation* prev = NULL; + for (e = v->first_expectation; e != NULL; e = e->next) { + if (e->tag == ev.tag) { + verify_matches(e, &ev); + if (e == v->first_expectation) v->first_expectation = e->next; + if (prev != NULL) prev->next = e->next; + gpr_free(e); + break; + } + prev = e; + } + if (e == NULL) { + char* s = grpc_event_string(&ev); + gpr_log(GPR_ERROR, "cq returned unexpected event: %s", s); + gpr_free(s); + gpr_strvec expectations; + gpr_strvec_init(&expectations); + expectations_to_strvec(&expectations, v); + s = gpr_strvec_flatten(&expectations, NULL); + gpr_strvec_destroy(&expectations); + gpr_log(GPR_ERROR, "expected tags:\n%s", s); + gpr_free(s); + abort(); + } + } +} + +void cq_verify_empty_timeout(cq_verifier* v, int timeout_sec) { + gpr_timespec deadline = + gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), + gpr_time_from_seconds(timeout_sec, GPR_TIMESPAN)); + grpc_event ev; + + GPR_ASSERT(v->first_expectation == NULL && "expectation queue must be empty"); + + ev = grpc_completion_queue_next(v->cq, deadline, NULL); + if (ev.type != GRPC_QUEUE_TIMEOUT) { + char* s = grpc_event_string(&ev); + gpr_log(GPR_ERROR, "unexpected event (expected nothing): %s", s); + gpr_free(s); + abort(); + } +} + +void cq_verify_empty(cq_verifier* v) { cq_verify_empty_timeout(v, 1); } + +static void add(cq_verifier* v, const char* file, int line, + grpc_completion_type type, void* tag, bool success) { + expectation* e = (expectation*)gpr_malloc(sizeof(expectation)); + e->type = type; + e->file = file; + e->line = line; + e->tag = tag; + e->success = success; + e->next = v->first_expectation; + v->first_expectation = e; +} + +void cq_expect_completion(cq_verifier* v, const char* file, int line, void* tag, + bool success) { + add(v, file, line, GRPC_OP_COMPLETE, tag, success); +} |