test/core/end2end/cq_verifier.cc - third_party/grpc - Git at Google

 /*
  *
  * 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 = nullptr;
   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 != nullptr; 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, nullptr);
   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, nullptr);
         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 != nullptr) {
     grpc_event ev = grpc_completion_queue_next(v->cq, deadline, nullptr);
     if (ev.type == GRPC_QUEUE_TIMEOUT) {
       fail_no_event_received(v);
       break;
     }
     expectation* e;
     expectation* prev = nullptr;
     for (e = v->first_expectation; e != nullptr; e = e->next) {
       if (e->tag == ev.tag) {
         verify_matches(e, &ev);
         if (e == v->first_expectation) v->first_expectation = e->next;
         if (prev != nullptr) prev->next = e->next;
         gpr_free(e);
         break;
       }
       prev = e;
     }
     if (e == nullptr) {
       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, nullptr);
       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 == nullptr &&
              "expectation queue must be empty");

   ev = grpc_completion_queue_next(v->cq, deadline, nullptr);
   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);
 }
	/*
	*
	* 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 = nullptr;
	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 != nullptr; 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, nullptr);
	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, nullptr);
	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 != nullptr) {
	grpc_event ev = grpc_completion_queue_next(v->cq, deadline, nullptr);
	if (ev.type == GRPC_QUEUE_TIMEOUT) {
	fail_no_event_received(v);
	break;
	}
	expectation* e;
	expectation* prev = nullptr;
	for (e = v->first_expectation; e != nullptr; e = e->next) {
	if (e->tag == ev.tag) {
	verify_matches(e, &ev);
	if (e == v->first_expectation) v->first_expectation = e->next;
	if (prev != nullptr) prev->next = e->next;
	gpr_free(e);
	break;
	}
	prev = e;
	}
	if (e == nullptr) {
	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, nullptr);
	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 == nullptr &&
	"expectation queue must be empty");

	ev = grpc_completion_queue_next(v->cq, deadline, nullptr);
	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);
	}