Initial checkin of gRPC to third_party/

third_party/grpc/test/core/end2end/cq_verifier.c

+/*
+ *
+ * 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 "test/core/end2end/cq_verifier.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "src/core/surface/event_string.h"
+#include "src/core/support/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>
+
+#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;
+  struct expectation *prev;
+  grpc_completion_type type;
+  void *tag;
+  int success;
+} expectation;
+
+/* the verifier itself */
+struct cq_verifier {
+  /* bound completion queue */
+  grpc_completion_queue *cq;
+  /* the root/sentinal expectation */
+  expectation expect;
+};
+
+cq_verifier *cq_verifier_create(grpc_completion_queue *cq) {
+  cq_verifier *v = gpr_malloc(sizeof(cq_verifier));
+  v->expect.type = ROOT_EXPECTATION;
+  v->expect.tag = NULL;
+  v->expect.next = &v->expect;
+  v->expect.prev = &v->expect;
+  v->cq = cq;
+  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 == strcmp(key, md[i].key) && strlen(value) == md[i].value_length &&
+        0 == memcmp(md[i].value, value, md[i].value_length)) {
+      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 gpr_slice merge_slices(gpr_slice *slices, size_t nslices) {
+  size_t i;
+  size_t len = 0;
+  uint8_t *cursor;
+  gpr_slice out;
+
+  for (i = 0; i < nslices; i++) {
+    len += GPR_SLICE_LENGTH(slices[i]);
+  }
+
+  out = gpr_slice_malloc(len);
+  cursor = GPR_SLICE_START_PTR(out);
+
+  for (i = 0; i < nslices; i++) {
+    memcpy(cursor, GPR_SLICE_START_PTR(slices[i]), GPR_SLICE_LENGTH(slices[i]));
+    cursor += GPR_SLICE_LENGTH(slices[i]);
+  }
+
+  return out;
+}
+
+static int byte_buffer_eq_slice(grpc_byte_buffer *bb, gpr_slice b) {
+  gpr_slice a;
+  int ok;
+
+  if (!bb) return 0;
+
+  a = merge_slices(bb->data.raw.slice_buffer.slices,
+                   bb->data.raw.slice_buffer.count);
+  ok = GPR_SLICE_LENGTH(a) == GPR_SLICE_LENGTH(b) &&
+       0 == memcmp(GPR_SLICE_START_PTR(a), GPR_SLICE_START_PTR(b),
+                   GPR_SLICE_LENGTH(a));
+  gpr_slice_unref(a);
+  gpr_slice_unref(b);
+  return ok;
+}
+
+int byte_buffer_eq_string(grpc_byte_buffer *bb, const char *str) {
+  grpc_byte_buffer_reader reader;
+  grpc_byte_buffer *rbb;
+  int res;
+
+  grpc_byte_buffer_reader_init(&reader, bb);
+  rbb = grpc_raw_byte_buffer_from_reader(&reader);
+  res = byte_buffer_eq_slice(rbb, gpr_slice_from_copied_string(str));
+  grpc_byte_buffer_reader_destroy(&reader);
+  grpc_byte_buffer_destroy(rbb);
+
+  return res;
+}
+
+static void verify_matches(expectation *e, grpc_event *ev) {
+  GPR_ASSERT(e->type == ev->type);
+  switch (e->type) {
+    case GRPC_QUEUE_SHUTDOWN:
+      gpr_log(GPR_ERROR, "premature queue shutdown");
+      abort();
+      break;
+    case GRPC_OP_COMPLETE:
+      GPR_ASSERT(e->success == ev->success);
+      break;
+    case GRPC_QUEUE_TIMEOUT:
+      gpr_log(GPR_ERROR, "not implemented");
+      abort();
+      break;
+  }
+}
+
+static void expectation_to_strvec(gpr_strvec *buf, expectation *e) {
+  char *tmp;
+
+  gpr_asprintf(&tmp, "%p ", e->tag);
+  gpr_strvec_add(buf, tmp);
+
+  switch (e->type) {
+    case GRPC_OP_COMPLETE:
+      gpr_asprintf(&tmp, "GRPC_OP_COMPLETE result=%d", e->success);
+      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->expect.next; e != &v->expect; 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();
+}
+
+void cq_verify(cq_verifier *v) {
+  gpr_timespec deadline = GRPC_TIMEOUT_SECONDS_TO_DEADLINE(10);
+  grpc_event ev;
+  expectation *e;
+  char *s;
+  gpr_strvec have_tags;
+
+  gpr_strvec_init(&have_tags);
+
+  while (v->expect.next != &v->expect) {
+    ev = grpc_completion_queue_next(v->cq, deadline, NULL);
+    if (ev.type == GRPC_QUEUE_TIMEOUT) {
+      fail_no_event_received(v);
+      break;
+    }
+
+    for (e = v->expect.next; e != &v->expect; e = e->next) {
+      gpr_asprintf(&s, " %p", e->tag);
+      gpr_strvec_add(&have_tags, s);
+      if (e->tag == ev.tag) {
+        verify_matches(e, &ev);
+        e->next->prev = e->prev;
+        e->prev->next = e->next;
+        gpr_free(e);
+        break;
+      }
+    }
+    if (e == &v->expect) {
+      s = grpc_event_string(&ev);
+      gpr_log(GPR_ERROR, "event not found: %s", s);
+      gpr_free(s);
+      s = gpr_strvec_flatten(&have_tags, NULL);
+      gpr_log(GPR_ERROR, "have tags:%s", s);
+      gpr_free(s);
+      gpr_strvec_destroy(&have_tags);
+      abort();
+    }
+  }
+
+  gpr_strvec_destroy(&have_tags);
+}
+
+void cq_verify_empty(cq_verifier *v) {
+  gpr_timespec deadline = gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
+                                       gpr_time_from_seconds(1, GPR_TIMESPAN));
+  grpc_event ev;
+
+  GPR_ASSERT(v->expect.next == &v->expect && "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();
+  }
+}
+
+static expectation *add(cq_verifier *v, grpc_completion_type type, void *tag) {
+  expectation *e = gpr_malloc(sizeof(expectation));
+  e->type = type;
+  e->tag = tag;
+  e->next = &v->expect;
+  e->prev = e->next->prev;
+  e->next->prev = e->prev->next = e;
+  return e;
+}
+
+void cq_expect_completion(cq_verifier *v, void *tag, int success) {
+  add(v, GRPC_OP_COMPLETE, tag)->success = success;
+}