aboutsummaryrefslogtreecommitdiffhomepage
path: root/test/core/transport
diff options
context:
space:
mode:
Diffstat (limited to 'test/core/transport')
-rw-r--r--test/core/transport/chttp2/bin_decoder_test.c2
-rw-r--r--test/core/transport/chttp2/bin_encoder_test.c8
-rw-r--r--test/core/transport/chttp2/hpack_encoder_test.c14
-rw-r--r--test/core/transport/chttp2/hpack_parser_fuzzer_test.c9
-rw-r--r--test/core/transport/chttp2/hpack_parser_test.c11
-rw-r--r--test/core/transport/chttp2/hpack_table_test.c37
-rw-r--r--test/core/transport/chttp2/status_conversion_test.c (renamed from test/core/transport/status_conversion_test.c)98
-rw-r--r--test/core/transport/chttp2/varint_test.c2
-rw-r--r--test/core/transport/metadata_test.c325
-rw-r--r--test/core/transport/timeout_encoding_test.c28
10 files changed, 224 insertions, 310 deletions
diff --git a/test/core/transport/chttp2/bin_decoder_test.c b/test/core/transport/chttp2/bin_decoder_test.c
index a8b0a75137..221112ab21 100644
--- a/test/core/transport/chttp2/bin_decoder_test.c
+++ b/test/core/transport/chttp2/bin_decoder_test.c
@@ -46,7 +46,7 @@ static int all_ok = 1;
static void expect_slice_eq(grpc_exec_ctx *exec_ctx, grpc_slice expected,
grpc_slice slice, char *debug, int line) {
- if (!grpc_slice_eq(slice, expected)) {
+ if (0 != grpc_slice_cmp(slice, expected)) {
char *hs = grpc_dump_slice(slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
char *he = grpc_dump_slice(expected, GPR_DUMP_HEX | GPR_DUMP_ASCII);
gpr_log(GPR_ERROR, "FAILED:%d: %s\ngot: %s\nwant: %s", line, debug, hs,
diff --git a/test/core/transport/chttp2/bin_encoder_test.c b/test/core/transport/chttp2/bin_encoder_test.c
index bd10a1e211..53b55a301e 100644
--- a/test/core/transport/chttp2/bin_encoder_test.c
+++ b/test/core/transport/chttp2/bin_encoder_test.c
@@ -48,7 +48,7 @@ static int all_ok = 1;
static void expect_slice_eq(grpc_slice expected, grpc_slice slice, char *debug,
int line) {
- if (!grpc_slice_eq(slice, expected)) {
+ if (0 != grpc_slice_cmp(slice, expected)) {
char *hs = grpc_dump_slice(slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
char *he = grpc_dump_slice(expected, GPR_DUMP_HEX | GPR_DUMP_ASCII);
gpr_log(GPR_ERROR, "FAILED:%d: %s\ngot: %s\nwant: %s", line, debug, hs,
@@ -84,8 +84,8 @@ static void expect_combined_equiv(const char *s, size_t len, int line) {
grpc_slice input = grpc_slice_from_copied_buffer(s, len);
grpc_slice base64 = grpc_chttp2_base64_encode(input);
grpc_slice expect = grpc_chttp2_huffman_compress(base64);
- grpc_slice got = grpc_chttp2_base64_encode_and_huffman_compress(input);
- if (!grpc_slice_eq(expect, got)) {
+ grpc_slice got = grpc_chttp2_base64_encode_and_huffman_compress_impl(input);
+ if (0 != grpc_slice_cmp(expect, got)) {
char *t = grpc_dump_slice(input, GPR_DUMP_HEX | GPR_DUMP_ASCII);
char *e = grpc_dump_slice(expect, GPR_DUMP_HEX | GPR_DUMP_ASCII);
char *g = grpc_dump_slice(got, GPR_DUMP_HEX | GPR_DUMP_ASCII);
@@ -106,7 +106,7 @@ static void expect_combined_equiv(const char *s, size_t len, int line) {
expect_combined_equiv(x, sizeof(x) - 1, __LINE__)
static void expect_binary_header(const char *hdr, int binary) {
- if (grpc_is_binary_header(grpc_slice_from_static_string(hdr)) != binary) {
+ if (grpc_is_binary_header(hdr, strlen(hdr)) != binary) {
gpr_log(GPR_ERROR, "FAILED: expected header '%s' to be %s", hdr,
binary ? "binary" : "not binary");
all_ok = 0;
diff --git a/test/core/transport/chttp2/hpack_encoder_test.c b/test/core/transport/chttp2/hpack_encoder_test.c
index d572d79a7f..1fd2540d65 100644
--- a/test/core/transport/chttp2/hpack_encoder_test.c
+++ b/test/core/transport/chttp2/hpack_encoder_test.c
@@ -81,9 +81,7 @@ static void verify(grpc_exec_ctx *exec_ctx, size_t window_available, int eof,
e[i - 1].next = &e[i];
e[i].prev = &e[i - 1];
}
- e[i].md = grpc_mdelem_from_slices(
- exec_ctx, grpc_slice_intern(grpc_slice_from_static_string(key)),
- grpc_slice_intern(grpc_slice_from_static_string(value)));
+ e[i].md = grpc_mdelem_from_strings(exec_ctx, key, value);
}
e[0].prev = NULL;
e[nheaders - 1].next = NULL;
@@ -91,7 +89,6 @@ static void verify(grpc_exec_ctx *exec_ctx, size_t window_available, int eof,
b.list.head = &e[0];
b.list.tail = &e[nheaders - 1];
- b.list.count = nheaders;
if (cap_to_delete == num_to_delete) {
cap_to_delete = GPR_MAX(2 * cap_to_delete, 1000);
@@ -109,7 +106,7 @@ static void verify(grpc_exec_ctx *exec_ctx, size_t window_available, int eof,
grpc_slice_buffer_destroy_internal(exec_ctx, &output);
grpc_metadata_batch_destroy(exec_ctx, &b);
- if (!grpc_slice_eq(merged, expect)) {
+ if (0 != grpc_slice_cmp(merged, expect)) {
char *expect_str = grpc_dump_slice(expect, GPR_DUMP_HEX | GPR_DUMP_ASCII);
char *got_str = grpc_dump_slice(merged, GPR_DUMP_HEX | GPR_DUMP_ASCII);
gpr_log(GPR_ERROR, "mismatched output for %s", expected);
@@ -196,9 +193,7 @@ static void verify_table_size_change_match_elem_size(grpc_exec_ctx *exec_ctx,
const char *key,
const char *value) {
grpc_slice_buffer output;
- grpc_mdelem elem = grpc_mdelem_from_slices(
- exec_ctx, grpc_slice_intern(grpc_slice_from_static_string(key)),
- grpc_slice_intern(grpc_slice_from_static_string(value)));
+ grpc_mdelem *elem = grpc_mdelem_from_strings(exec_ctx, key, value);
size_t elem_size = grpc_mdelem_get_size_in_hpack_table(elem);
size_t initial_table_size = g_compressor.table_size;
grpc_linked_mdelem *e = gpr_malloc(sizeof(*e));
@@ -209,7 +204,6 @@ static void verify_table_size_change_match_elem_size(grpc_exec_ctx *exec_ctx,
e[0].next = NULL;
b.list.head = &e[0];
b.list.tail = &e[0];
- b.list.count = 1;
grpc_slice_buffer_init(&output);
grpc_transport_one_way_stats stats;
@@ -239,7 +233,7 @@ static void run_test(void (*test)(grpc_exec_ctx *exec_ctx), const char *name) {
int main(int argc, char **argv) {
size_t i;
- grpc_test_only_set_slice_hash_seed(0);
+ grpc_test_only_set_metadata_hash_seed(0);
grpc_test_init(argc, argv);
grpc_init();
TEST(test_basic_headers);
diff --git a/test/core/transport/chttp2/hpack_parser_fuzzer_test.c b/test/core/transport/chttp2/hpack_parser_fuzzer_test.c
index e9ac16df2d..4e00f49b66 100644
--- a/test/core/transport/chttp2/hpack_parser_fuzzer_test.c
+++ b/test/core/transport/chttp2/hpack_parser_fuzzer_test.c
@@ -39,26 +39,25 @@
#include <grpc/support/log.h>
#include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
-#include "src/core/lib/slice/slice_internal.h"
bool squelch = true;
bool leak_check = true;
-static void onhdr(grpc_exec_ctx *exec_ctx, void *ud, grpc_mdelem md) {
+static void onhdr(grpc_exec_ctx *exec_ctx, void *ud, grpc_mdelem *md) {
GRPC_MDELEM_UNREF(exec_ctx, md);
}
static void dont_log(gpr_log_func_args *args) {}
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
- grpc_test_only_set_slice_hash_seed(0);
+ grpc_test_only_set_metadata_hash_seed(0);
if (squelch) gpr_set_log_function(dont_log);
grpc_init();
grpc_chttp2_hpack_parser parser;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
grpc_chttp2_hpack_parser_init(&exec_ctx, &parser);
parser.on_header = onhdr;
- GRPC_ERROR_UNREF(grpc_chttp2_hpack_parser_parse(
- &exec_ctx, &parser, grpc_slice_from_static_buffer(data, size)));
+ GRPC_ERROR_UNREF(
+ grpc_chttp2_hpack_parser_parse(&exec_ctx, &parser, data, data + size));
grpc_chttp2_hpack_parser_destroy(&exec_ctx, &parser);
grpc_exec_ctx_finish(&exec_ctx);
grpc_shutdown();
diff --git a/test/core/transport/chttp2/hpack_parser_test.c b/test/core/transport/chttp2/hpack_parser_test.c
index 01789c4fb4..8f48849c97 100644
--- a/test/core/transport/chttp2/hpack_parser_test.c
+++ b/test/core/transport/chttp2/hpack_parser_test.c
@@ -45,15 +45,15 @@
typedef struct { va_list args; } test_checker;
-static void onhdr(grpc_exec_ctx *exec_ctx, void *ud, grpc_mdelem md) {
+static void onhdr(grpc_exec_ctx *exec_ctx, void *ud, grpc_mdelem *md) {
const char *ekey, *evalue;
test_checker *chk = ud;
ekey = va_arg(chk->args, char *);
GPR_ASSERT(ekey);
evalue = va_arg(chk->args, char *);
GPR_ASSERT(evalue);
- GPR_ASSERT(grpc_slice_str_cmp(GRPC_MDKEY(md), ekey) == 0);
- GPR_ASSERT(grpc_slice_str_cmp(GRPC_MDVALUE(md), evalue) == 0);
+ GPR_ASSERT(grpc_slice_str_cmp(md->key->slice, ekey) == 0);
+ GPR_ASSERT(grpc_slice_str_cmp(md->value->slice, evalue) == 0);
GRPC_MDELEM_UNREF(exec_ctx, md);
}
@@ -76,8 +76,9 @@ static void test_vector(grpc_chttp2_hpack_parser *parser,
for (i = 0; i < nslices; i++) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- GPR_ASSERT(grpc_chttp2_hpack_parser_parse(&exec_ctx, parser, slices[i]) ==
- GRPC_ERROR_NONE);
+ GPR_ASSERT(grpc_chttp2_hpack_parser_parse(
+ &exec_ctx, parser, GRPC_SLICE_START_PTR(slices[i]),
+ GRPC_SLICE_END_PTR(slices[i])) == GRPC_ERROR_NONE);
grpc_exec_ctx_finish(&exec_ctx);
}
diff --git a/test/core/transport/chttp2/hpack_table_test.c b/test/core/transport/chttp2/hpack_table_test.c
index d2f6d5dc5b..ef2ad66b5c 100644
--- a/test/core/transport/chttp2/hpack_table_test.c
+++ b/test/core/transport/chttp2/hpack_table_test.c
@@ -46,16 +46,16 @@
#define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x)
-static void assert_str(const grpc_chttp2_hptbl *tbl, grpc_slice mdstr,
+static void assert_str(const grpc_chttp2_hptbl *tbl, grpc_mdstr *mdstr,
const char *str) {
- GPR_ASSERT(grpc_slice_str_cmp(mdstr, str) == 0);
+ GPR_ASSERT(grpc_slice_str_cmp(mdstr->slice, str) == 0);
}
static void assert_index(const grpc_chttp2_hptbl *tbl, uint32_t idx,
const char *key, const char *value) {
- grpc_mdelem md = grpc_chttp2_hptbl_lookup(tbl, idx);
- assert_str(tbl, GRPC_MDKEY(md), key);
- assert_str(tbl, GRPC_MDVALUE(md), value);
+ grpc_mdelem *md = grpc_chttp2_hptbl_lookup(tbl, idx);
+ assert_str(tbl, md->key, key);
+ assert_str(tbl, md->value, value);
}
static void test_static_lookup(void) {
@@ -143,12 +143,10 @@ static void test_many_additions(void) {
grpc_chttp2_hptbl_init(&exec_ctx, &tbl);
for (i = 0; i < 100000; i++) {
- grpc_mdelem elem;
+ grpc_mdelem *elem;
gpr_asprintf(&key, "K:%d", i);
gpr_asprintf(&value, "VALUE:%d", i);
- elem =
- grpc_mdelem_from_slices(&exec_ctx, grpc_slice_from_copied_string(key),
- grpc_slice_from_copied_string(value));
+ elem = grpc_mdelem_from_strings(&exec_ctx, key, value);
GPR_ASSERT(grpc_chttp2_hptbl_add(&exec_ctx, &tbl, elem) == GRPC_ERROR_NONE);
GRPC_MDELEM_UNREF(&exec_ctx, elem);
assert_index(&tbl, 1 + GRPC_CHTTP2_LAST_STATIC_ENTRY, key, value);
@@ -171,9 +169,7 @@ static grpc_chttp2_hptbl_find_result find_simple(grpc_chttp2_hptbl *tbl,
const char *key,
const char *value) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_mdelem md =
- grpc_mdelem_from_slices(&exec_ctx, grpc_slice_from_copied_string(key),
- grpc_slice_from_copied_string(value));
+ grpc_mdelem *md = grpc_mdelem_from_strings(&exec_ctx, key, value);
grpc_chttp2_hptbl_find_result r = grpc_chttp2_hptbl_find(tbl, md);
GRPC_MDELEM_UNREF(&exec_ctx, md);
grpc_exec_ctx_finish(&exec_ctx);
@@ -185,24 +181,19 @@ static void test_find(void) {
grpc_chttp2_hptbl tbl;
uint32_t i;
char buffer[32];
- grpc_mdelem elem;
+ grpc_mdelem *elem;
grpc_chttp2_hptbl_find_result r;
LOG_TEST("test_find");
grpc_chttp2_hptbl_init(&exec_ctx, &tbl);
- elem =
- grpc_mdelem_from_slices(&exec_ctx, grpc_slice_from_static_string("abc"),
- grpc_slice_from_static_string("xyz"));
+ elem = grpc_mdelem_from_strings(&exec_ctx, "abc", "xyz");
GPR_ASSERT(grpc_chttp2_hptbl_add(&exec_ctx, &tbl, elem) == GRPC_ERROR_NONE);
GRPC_MDELEM_UNREF(&exec_ctx, elem);
- elem =
- grpc_mdelem_from_slices(&exec_ctx, grpc_slice_from_static_string("abc"),
- grpc_slice_from_static_string("123"));
+ elem = grpc_mdelem_from_strings(&exec_ctx, "abc", "123");
GPR_ASSERT(grpc_chttp2_hptbl_add(&exec_ctx, &tbl, elem) == GRPC_ERROR_NONE);
GRPC_MDELEM_UNREF(&exec_ctx, elem);
- elem = grpc_mdelem_from_slices(&exec_ctx, grpc_slice_from_static_string("x"),
- grpc_slice_from_static_string("1"));
+ elem = grpc_mdelem_from_strings(&exec_ctx, "x", "1");
GPR_ASSERT(grpc_chttp2_hptbl_add(&exec_ctx, &tbl, elem) == GRPC_ERROR_NONE);
GRPC_MDELEM_UNREF(&exec_ctx, elem);
@@ -253,9 +244,7 @@ static void test_find(void) {
/* overflow the string buffer, check find still works */
for (i = 0; i < 10000; i++) {
int64_ttoa(i, buffer);
- elem = grpc_mdelem_from_slices(&exec_ctx,
- grpc_slice_from_static_string("test"),
- grpc_slice_from_copied_string(buffer));
+ elem = grpc_mdelem_from_strings(&exec_ctx, "test", buffer);
GPR_ASSERT(grpc_chttp2_hptbl_add(&exec_ctx, &tbl, elem) == GRPC_ERROR_NONE);
GRPC_MDELEM_UNREF(&exec_ctx, elem);
}
diff --git a/test/core/transport/status_conversion_test.c b/test/core/transport/chttp2/status_conversion_test.c
index 65f840b1e2..f5a5cd1395 100644
--- a/test/core/transport/status_conversion_test.c
+++ b/test/core/transport/chttp2/status_conversion_test.c
@@ -31,50 +31,50 @@
*
*/
-#include "src/core/lib/transport/status_conversion.h"
+#include "src/core/ext/transport/chttp2/transport/status_conversion.h"
#include <grpc/support/log.h>
#include "test/core/util/test_config.h"
#define GRPC_STATUS_TO_HTTP2_ERROR(a, b) \
- GPR_ASSERT(grpc_status_to_http2_error(a) == (b))
+ GPR_ASSERT(grpc_chttp2_grpc_status_to_http2_error(a) == (b))
#define HTTP2_ERROR_TO_GRPC_STATUS(a, deadline, b) \
- GPR_ASSERT(grpc_http2_error_to_grpc_status(a, deadline) == (b))
+ GPR_ASSERT(grpc_chttp2_http2_error_to_grpc_status(a, deadline) == (b))
#define GRPC_STATUS_TO_HTTP2_STATUS(a, b) \
- GPR_ASSERT(grpc_status_to_http2_status(a) == (b))
+ GPR_ASSERT(grpc_chttp2_grpc_status_to_http2_status(a) == (b))
#define HTTP2_STATUS_TO_GRPC_STATUS(a, b) \
- GPR_ASSERT(grpc_http2_status_to_grpc_status(a) == (b))
+ GPR_ASSERT(grpc_chttp2_http2_status_to_grpc_status(a) == (b))
int main(int argc, char **argv) {
int i;
grpc_test_init(argc, argv);
- GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_OK, GRPC_HTTP2_NO_ERROR);
- GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_CANCELLED, GRPC_HTTP2_CANCEL);
- GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_UNKNOWN, GRPC_HTTP2_INTERNAL_ERROR);
+ GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_OK, GRPC_CHTTP2_NO_ERROR);
+ GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_CANCELLED, GRPC_CHTTP2_CANCEL);
+ GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_UNKNOWN, GRPC_CHTTP2_INTERNAL_ERROR);
GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_INVALID_ARGUMENT,
- GRPC_HTTP2_INTERNAL_ERROR);
- GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_DEADLINE_EXCEEDED, GRPC_HTTP2_CANCEL);
- GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_NOT_FOUND, GRPC_HTTP2_INTERNAL_ERROR);
+ GRPC_CHTTP2_INTERNAL_ERROR);
+ GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_DEADLINE_EXCEEDED, GRPC_CHTTP2_CANCEL);
+ GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_NOT_FOUND, GRPC_CHTTP2_INTERNAL_ERROR);
GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_ALREADY_EXISTS,
- GRPC_HTTP2_INTERNAL_ERROR);
+ GRPC_CHTTP2_INTERNAL_ERROR);
GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_PERMISSION_DENIED,
- GRPC_HTTP2_INADEQUATE_SECURITY);
+ GRPC_CHTTP2_INADEQUATE_SECURITY);
GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_UNAUTHENTICATED,
- GRPC_HTTP2_INTERNAL_ERROR);
+ GRPC_CHTTP2_INTERNAL_ERROR);
GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_RESOURCE_EXHAUSTED,
- GRPC_HTTP2_ENHANCE_YOUR_CALM);
+ GRPC_CHTTP2_ENHANCE_YOUR_CALM);
GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_FAILED_PRECONDITION,
- GRPC_HTTP2_INTERNAL_ERROR);
- GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_ABORTED, GRPC_HTTP2_INTERNAL_ERROR);
+ GRPC_CHTTP2_INTERNAL_ERROR);
+ GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_ABORTED, GRPC_CHTTP2_INTERNAL_ERROR);
GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_OUT_OF_RANGE,
- GRPC_HTTP2_INTERNAL_ERROR);
+ GRPC_CHTTP2_INTERNAL_ERROR);
GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_UNIMPLEMENTED,
- GRPC_HTTP2_INTERNAL_ERROR);
- GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_INTERNAL, GRPC_HTTP2_INTERNAL_ERROR);
+ GRPC_CHTTP2_INTERNAL_ERROR);
+ GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_INTERNAL, GRPC_CHTTP2_INTERNAL_ERROR);
GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_UNAVAILABLE,
- GRPC_HTTP2_REFUSED_STREAM);
- GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_DATA_LOSS, GRPC_HTTP2_INTERNAL_ERROR);
+ GRPC_CHTTP2_REFUSED_STREAM);
+ GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_DATA_LOSS, GRPC_CHTTP2_INTERNAL_ERROR);
GRPC_STATUS_TO_HTTP2_STATUS(GRPC_STATUS_OK, 200);
GRPC_STATUS_TO_HTTP2_STATUS(GRPC_STATUS_CANCELLED, 200);
@@ -95,59 +95,59 @@ int main(int argc, char **argv) {
GRPC_STATUS_TO_HTTP2_STATUS(GRPC_STATUS_DATA_LOSS, 200);
const gpr_timespec before_deadline = gpr_inf_future(GPR_CLOCK_MONOTONIC);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_NO_ERROR, before_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_NO_ERROR, before_deadline,
GRPC_STATUS_INTERNAL);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_PROTOCOL_ERROR, before_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_PROTOCOL_ERROR, before_deadline,
GRPC_STATUS_INTERNAL);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_INTERNAL_ERROR, before_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_INTERNAL_ERROR, before_deadline,
GRPC_STATUS_INTERNAL);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_FLOW_CONTROL_ERROR, before_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_FLOW_CONTROL_ERROR, before_deadline,
GRPC_STATUS_INTERNAL);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_SETTINGS_TIMEOUT, before_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_SETTINGS_TIMEOUT, before_deadline,
GRPC_STATUS_INTERNAL);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_STREAM_CLOSED, before_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_STREAM_CLOSED, before_deadline,
GRPC_STATUS_INTERNAL);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_FRAME_SIZE_ERROR, before_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_FRAME_SIZE_ERROR, before_deadline,
GRPC_STATUS_INTERNAL);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_REFUSED_STREAM, before_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_REFUSED_STREAM, before_deadline,
GRPC_STATUS_UNAVAILABLE);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_CANCEL, before_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_CANCEL, before_deadline,
GRPC_STATUS_CANCELLED);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_COMPRESSION_ERROR, before_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_COMPRESSION_ERROR, before_deadline,
GRPC_STATUS_INTERNAL);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_CONNECT_ERROR, before_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_CONNECT_ERROR, before_deadline,
GRPC_STATUS_INTERNAL);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_ENHANCE_YOUR_CALM, before_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_ENHANCE_YOUR_CALM, before_deadline,
GRPC_STATUS_RESOURCE_EXHAUSTED);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_INADEQUATE_SECURITY, before_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_INADEQUATE_SECURITY, before_deadline,
GRPC_STATUS_PERMISSION_DENIED);
const gpr_timespec after_deadline = gpr_inf_past(GPR_CLOCK_MONOTONIC);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_NO_ERROR, after_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_NO_ERROR, after_deadline,
GRPC_STATUS_INTERNAL);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_PROTOCOL_ERROR, after_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_PROTOCOL_ERROR, after_deadline,
GRPC_STATUS_INTERNAL);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_INTERNAL_ERROR, after_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_INTERNAL_ERROR, after_deadline,
GRPC_STATUS_INTERNAL);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_FLOW_CONTROL_ERROR, after_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_FLOW_CONTROL_ERROR, after_deadline,
GRPC_STATUS_INTERNAL);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_SETTINGS_TIMEOUT, after_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_SETTINGS_TIMEOUT, after_deadline,
GRPC_STATUS_INTERNAL);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_STREAM_CLOSED, after_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_STREAM_CLOSED, after_deadline,
GRPC_STATUS_INTERNAL);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_FRAME_SIZE_ERROR, after_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_FRAME_SIZE_ERROR, after_deadline,
GRPC_STATUS_INTERNAL);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_REFUSED_STREAM, after_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_REFUSED_STREAM, after_deadline,
GRPC_STATUS_UNAVAILABLE);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_CANCEL, after_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_CANCEL, after_deadline,
GRPC_STATUS_DEADLINE_EXCEEDED);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_COMPRESSION_ERROR, after_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_COMPRESSION_ERROR, after_deadline,
GRPC_STATUS_INTERNAL);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_CONNECT_ERROR, after_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_CONNECT_ERROR, after_deadline,
GRPC_STATUS_INTERNAL);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_ENHANCE_YOUR_CALM, after_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_ENHANCE_YOUR_CALM, after_deadline,
GRPC_STATUS_RESOURCE_EXHAUSTED);
- HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_INADEQUATE_SECURITY, after_deadline,
+ HTTP2_ERROR_TO_GRPC_STATUS(GRPC_CHTTP2_INADEQUATE_SECURITY, after_deadline,
GRPC_STATUS_PERMISSION_DENIED);
HTTP2_STATUS_TO_GRPC_STATUS(200, GRPC_STATUS_OK);
@@ -165,7 +165,7 @@ int main(int argc, char **argv) {
/* check all status values can be converted */
for (i = 0; i <= 999; i++) {
- grpc_http2_status_to_grpc_status(i);
+ grpc_chttp2_http2_status_to_grpc_status(i);
}
return 0;
diff --git a/test/core/transport/chttp2/varint_test.c b/test/core/transport/chttp2/varint_test.c
index f12c340a4b..e29be4b056 100644
--- a/test/core/transport/chttp2/varint_test.c
+++ b/test/core/transport/chttp2/varint_test.c
@@ -49,7 +49,7 @@ static void test_varint(uint32_t value, uint32_t prefix_bits, uint8_t prefix_or,
slice = grpc_slice_malloc(nbytes);
GRPC_CHTTP2_WRITE_VARINT(value, prefix_bits, prefix_or,
GRPC_SLICE_START_PTR(slice), nbytes);
- GPR_ASSERT(grpc_slice_eq(expect, slice));
+ GPR_ASSERT(grpc_slice_cmp(expect, slice) == 0);
grpc_slice_unref(expect);
grpc_slice_unref(slice);
}
diff --git a/test/core/transport/metadata_test.c b/test/core/transport/metadata_test.c
index 92e58f2375..3625043d07 100644
--- a/test/core/transport/metadata_test.c
+++ b/test/core/transport/metadata_test.c
@@ -47,51 +47,55 @@
#include "src/core/lib/transport/static_metadata.h"
#include "test/core/util/test_config.h"
+#define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x)
+
/* a large number */
#define MANY 10000
static void test_no_op(void) {
- gpr_log(GPR_INFO, "test_no_op");
+ LOG_TEST("test_no_op");
grpc_init();
grpc_shutdown();
}
-static grpc_slice maybe_intern(grpc_slice in, bool intern) {
- grpc_slice out = intern ? grpc_slice_intern(in) : grpc_slice_ref(in);
- grpc_slice_unref(in);
- return out;
-}
+static void test_create_string(void) {
+ grpc_mdstr *s1, *s2, *s3;
+
+ LOG_TEST("test_create_string");
-static grpc_slice maybe_dup(grpc_slice in, bool dup) {
- grpc_slice out = dup ? grpc_slice_dup(in) : grpc_slice_ref(in);
- grpc_slice_unref(in);
- return out;
+ grpc_init();
+ grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+ s1 = grpc_mdstr_from_string("hello");
+ s2 = grpc_mdstr_from_string("hello");
+ s3 = grpc_mdstr_from_string("very much not hello");
+ GPR_ASSERT(s1 == s2);
+ GPR_ASSERT(s3 != s1);
+ GPR_ASSERT(grpc_slice_str_cmp(s1->slice, "hello") == 0);
+ GPR_ASSERT(grpc_slice_str_cmp(s3->slice, "very much not hello") == 0);
+ GRPC_MDSTR_UNREF(&exec_ctx, s1);
+ GRPC_MDSTR_UNREF(&exec_ctx, s2);
+ GRPC_MDSTR_UNREF(&exec_ctx, s3);
+ grpc_exec_ctx_finish(&exec_ctx);
+ grpc_shutdown();
}
-static void test_create_metadata(bool intern_keys, bool intern_values) {
- grpc_mdelem m1, m2, m3;
+static void test_create_metadata(void) {
+ grpc_mdelem *m1, *m2, *m3;
- gpr_log(GPR_INFO, "test_create_metadata: intern_keys=%d intern_values=%d",
- intern_keys, intern_values);
+ LOG_TEST("test_create_metadata");
grpc_init();
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- m1 = grpc_mdelem_from_slices(
- &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
- maybe_intern(grpc_slice_from_static_string("b"), intern_values));
- m2 = grpc_mdelem_from_slices(
- &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
- maybe_intern(grpc_slice_from_static_string("b"), intern_values));
- m3 = grpc_mdelem_from_slices(
- &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
- maybe_intern(grpc_slice_from_static_string("c"), intern_values));
- GPR_ASSERT(grpc_mdelem_eq(m1, m2));
- GPR_ASSERT(!grpc_mdelem_eq(m3, m1));
- GPR_ASSERT(grpc_slice_eq(GRPC_MDKEY(m3), GRPC_MDKEY(m1)));
- GPR_ASSERT(!grpc_slice_eq(GRPC_MDVALUE(m3), GRPC_MDVALUE(m1)));
- GPR_ASSERT(grpc_slice_str_cmp(GRPC_MDKEY(m1), "a") == 0);
- GPR_ASSERT(grpc_slice_str_cmp(GRPC_MDVALUE(m1), "b") == 0);
- GPR_ASSERT(grpc_slice_str_cmp(GRPC_MDVALUE(m3), "c") == 0);
+ m1 = grpc_mdelem_from_strings(&exec_ctx, "a", "b");
+ m2 = grpc_mdelem_from_strings(&exec_ctx, "a", "b");
+ m3 = grpc_mdelem_from_strings(&exec_ctx, "a", "c");
+ GPR_ASSERT(m1 == m2);
+ GPR_ASSERT(m3 != m1);
+ GPR_ASSERT(m3->key == m1->key);
+ GPR_ASSERT(m3->value != m1->value);
+ GPR_ASSERT(grpc_slice_str_cmp(m1->key->slice, "a") == 0);
+ GPR_ASSERT(grpc_slice_str_cmp(m1->value->slice, "b") == 0);
+ GPR_ASSERT(grpc_slice_str_cmp(m3->value->slice, "c") == 0);
GRPC_MDELEM_UNREF(&exec_ctx, m1);
GRPC_MDELEM_UNREF(&exec_ctx, m2);
GRPC_MDELEM_UNREF(&exec_ctx, m3);
@@ -99,28 +103,19 @@ static void test_create_metadata(bool intern_keys, bool intern_values) {
grpc_shutdown();
}
-static void test_create_many_ephemeral_metadata(bool intern_keys,
- bool intern_values) {
+static void test_create_many_ephemeral_metadata(void) {
char buffer[GPR_LTOA_MIN_BUFSIZE];
long i;
- gpr_log(
- GPR_INFO,
- "test_create_many_ephemeral_metadata: intern_keys=%d intern_values=%d",
- intern_keys, intern_values);
+ LOG_TEST("test_create_many_ephemeral_metadata");
grpc_init();
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
/* add, and immediately delete a bunch of different elements */
for (i = 0; i < MANY; i++) {
gpr_ltoa(i, buffer);
- GRPC_MDELEM_UNREF(
- &exec_ctx,
- grpc_mdelem_from_slices(
- &exec_ctx,
- maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
- maybe_intern(grpc_slice_from_copied_string(buffer),
- intern_values)));
+ GRPC_MDELEM_UNREF(&exec_ctx,
+ grpc_mdelem_from_strings(&exec_ctx, "a", buffer));
}
grpc_exec_ctx_finish(&exec_ctx);
grpc_shutdown();
@@ -129,27 +124,23 @@ static void test_create_many_ephemeral_metadata(bool intern_keys,
static void test_create_many_persistant_metadata(void) {
char buffer[GPR_LTOA_MIN_BUFSIZE];
long i;
- grpc_mdelem *created = gpr_malloc(sizeof(grpc_mdelem) * MANY);
- grpc_mdelem md;
+ grpc_mdelem **created = gpr_malloc(sizeof(grpc_mdelem *) * MANY);
+ grpc_mdelem *md;
- gpr_log(GPR_INFO, "test_create_many_persistant_metadata");
+ LOG_TEST("test_create_many_persistant_metadata");
grpc_init();
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
/* add phase */
for (i = 0; i < MANY; i++) {
gpr_ltoa(i, buffer);
- created[i] = grpc_mdelem_from_slices(
- &exec_ctx, grpc_slice_intern(grpc_slice_from_static_string("a")),
- grpc_slice_intern(grpc_slice_from_static_string(buffer)));
+ created[i] = grpc_mdelem_from_strings(&exec_ctx, "a", buffer);
}
/* verify phase */
for (i = 0; i < MANY; i++) {
gpr_ltoa(i, buffer);
- md = grpc_mdelem_from_slices(
- &exec_ctx, grpc_slice_intern(grpc_slice_from_static_string("a")),
- grpc_slice_intern(grpc_slice_from_static_string(buffer)));
- GPR_ASSERT(grpc_mdelem_eq(md, created[i]));
+ md = grpc_mdelem_from_strings(&exec_ctx, "a", buffer);
+ GPR_ASSERT(md == created[i]);
GRPC_MDELEM_UNREF(&exec_ctx, md);
}
/* cleanup phase */
@@ -162,77 +153,14 @@ static void test_create_many_persistant_metadata(void) {
gpr_free(created);
}
-static void test_spin_creating_the_same_thing(bool intern_keys,
- bool intern_values) {
- gpr_log(GPR_INFO,
- "test_spin_creating_the_same_thing: intern_keys=%d intern_values=%d",
- intern_keys, intern_values);
-
- grpc_init();
- grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_mdelem a, b, c;
- GRPC_MDELEM_UNREF(
- &exec_ctx,
- a = grpc_mdelem_from_slices(
- &exec_ctx,
- maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
- maybe_intern(grpc_slice_from_static_string("b"), intern_values)));
- GRPC_MDELEM_UNREF(
- &exec_ctx,
- b = grpc_mdelem_from_slices(
- &exec_ctx,
- maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
- maybe_intern(grpc_slice_from_static_string("b"), intern_values)));
- GRPC_MDELEM_UNREF(
- &exec_ctx,
- c = grpc_mdelem_from_slices(
- &exec_ctx,
- maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
- maybe_intern(grpc_slice_from_static_string("b"), intern_values)));
- if (intern_keys && intern_values) {
- GPR_ASSERT(a.payload == b.payload);
- GPR_ASSERT(a.payload == c.payload);
- }
- grpc_exec_ctx_finish(&exec_ctx);
- grpc_shutdown();
-}
-
-static void test_identity_laws(bool intern_keys, bool intern_values) {
- gpr_log(GPR_INFO, "test_identity_laws: intern_keys=%d intern_values=%d",
- intern_keys, intern_values);
+static void test_spin_creating_the_same_thing(void) {
+ LOG_TEST("test_spin_creating_the_same_thing");
grpc_init();
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_mdelem a, b, c;
- a = grpc_mdelem_from_slices(
- &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
- maybe_intern(grpc_slice_from_static_string("b"), intern_values));
- b = grpc_mdelem_from_slices(
- &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
- maybe_intern(grpc_slice_from_static_string("b"), intern_values));
- c = grpc_mdelem_from_slices(
- &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
- maybe_intern(grpc_slice_from_static_string("b"), intern_values));
- GPR_ASSERT(grpc_mdelem_eq(a, a));
- GPR_ASSERT(grpc_mdelem_eq(b, b));
- GPR_ASSERT(grpc_mdelem_eq(c, c));
- GPR_ASSERT(grpc_mdelem_eq(a, b));
- GPR_ASSERT(grpc_mdelem_eq(b, c));
- GPR_ASSERT(grpc_mdelem_eq(a, c));
- GPR_ASSERT(grpc_mdelem_eq(b, a));
- GPR_ASSERT(grpc_mdelem_eq(c, b));
- GPR_ASSERT(grpc_mdelem_eq(c, a));
- if (intern_keys && intern_values) {
- GPR_ASSERT(a.payload == b.payload);
- GPR_ASSERT(a.payload == c.payload);
- } else {
- GPR_ASSERT(a.payload != b.payload);
- GPR_ASSERT(a.payload != c.payload);
- GPR_ASSERT(b.payload != c.payload);
- }
- GRPC_MDELEM_UNREF(&exec_ctx, a);
- GRPC_MDELEM_UNREF(&exec_ctx, b);
- GRPC_MDELEM_UNREF(&exec_ctx, c);
+ GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_from_strings(&exec_ctx, "a", "b"));
+ GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_from_strings(&exec_ctx, "a", "b"));
+ GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_from_strings(&exec_ctx, "a", "b"));
grpc_exec_ctx_finish(&exec_ctx);
grpc_shutdown();
}
@@ -241,25 +169,25 @@ static void test_things_stick_around(void) {
size_t i, j;
char *buffer;
size_t nstrs = 1000;
- grpc_slice *strs = gpr_malloc(sizeof(grpc_slice) * nstrs);
+ grpc_mdstr **strs = gpr_malloc(sizeof(grpc_mdstr *) * nstrs);
size_t *shuf = gpr_malloc(sizeof(size_t) * nstrs);
- grpc_slice test;
+ grpc_mdstr *test;
- gpr_log(GPR_INFO, "test_things_stick_around");
+ LOG_TEST("test_things_stick_around");
grpc_init();
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
for (i = 0; i < nstrs; i++) {
gpr_asprintf(&buffer, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%" PRIuPTR "x", i);
- strs[i] = grpc_slice_intern(grpc_slice_from_static_string(buffer));
+ strs[i] = grpc_mdstr_from_string(buffer);
shuf[i] = i;
gpr_free(buffer);
}
for (i = 0; i < nstrs; i++) {
- grpc_slice_ref_internal(strs[i]);
- grpc_slice_unref_internal(&exec_ctx, strs[i]);
+ GRPC_MDSTR_REF(strs[i]);
+ GRPC_MDSTR_UNREF(&exec_ctx, strs[i]);
}
for (i = 0; i < nstrs; i++) {
@@ -271,13 +199,13 @@ static void test_things_stick_around(void) {
}
for (i = 0; i < nstrs; i++) {
- grpc_slice_unref_internal(&exec_ctx, strs[shuf[i]]);
+ GRPC_MDSTR_UNREF(&exec_ctx, strs[shuf[i]]);
for (j = i + 1; j < nstrs; j++) {
gpr_asprintf(&buffer, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%" PRIuPTR "x",
shuf[j]);
- test = grpc_slice_intern(grpc_slice_from_static_string(buffer));
- GPR_ASSERT(grpc_slice_is_equivalent(test, strs[shuf[j]]));
- grpc_slice_unref_internal(&exec_ctx, test);
+ test = grpc_mdstr_from_string(buffer);
+ GPR_ASSERT(test == strs[shuf[j]]);
+ GRPC_MDSTR_UNREF(&exec_ctx, test);
gpr_free(buffer);
}
}
@@ -288,11 +216,57 @@ static void test_things_stick_around(void) {
gpr_free(shuf);
}
+static void test_slices_work(void) {
+ /* ensure no memory leaks when switching representation from mdstr to slice */
+ grpc_mdstr *str;
+ grpc_slice slice;
+
+ LOG_TEST("test_slices_work");
+
+ grpc_init();
+ grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+
+ str = grpc_mdstr_from_string(
+ "123456789012345678901234567890123456789012345678901234567890");
+ slice = grpc_slice_ref(str->slice);
+ GRPC_MDSTR_UNREF(&exec_ctx, str);
+ grpc_slice_unref_internal(&exec_ctx, slice);
+
+ str = grpc_mdstr_from_string(
+ "123456789012345678901234567890123456789012345678901234567890");
+ slice = grpc_slice_ref(str->slice);
+ grpc_slice_unref_internal(&exec_ctx, slice);
+ GRPC_MDSTR_UNREF(&exec_ctx, str);
+
+ grpc_exec_ctx_finish(&exec_ctx);
+ grpc_shutdown();
+}
+
+static void test_base64_and_huffman_works(void) {
+ grpc_mdstr *str;
+ grpc_slice slice1;
+ grpc_slice slice2;
+
+ LOG_TEST("test_base64_and_huffman_works");
+
+ grpc_init();
+ grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+ str = grpc_mdstr_from_string("abcdefg");
+ slice1 = grpc_mdstr_as_base64_encoded_and_huffman_compressed(str);
+ slice2 = grpc_chttp2_base64_encode_and_huffman_compress(str->slice);
+ GPR_ASSERT(0 == grpc_slice_cmp(slice1, slice2));
+
+ grpc_slice_unref_internal(&exec_ctx, slice2);
+ GRPC_MDSTR_UNREF(&exec_ctx, str);
+ grpc_exec_ctx_finish(&exec_ctx);
+ grpc_shutdown();
+}
+
static void test_user_data_works(void) {
int *ud1;
int *ud2;
- grpc_mdelem md;
- gpr_log(GPR_INFO, "test_user_data_works");
+ grpc_mdelem *md;
+ LOG_TEST("test_user_data_works");
grpc_init();
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -300,9 +274,7 @@ static void test_user_data_works(void) {
*ud1 = 1;
ud2 = gpr_malloc(sizeof(int));
*ud2 = 2;
- md = grpc_mdelem_from_slices(
- &exec_ctx, grpc_slice_intern(grpc_slice_from_static_string("abc")),
- grpc_slice_intern(grpc_slice_from_static_string("123")));
+ md = grpc_mdelem_from_strings(&exec_ctx, "abc", "123");
grpc_mdelem_set_user_data(md, gpr_free, ud1);
grpc_mdelem_set_user_data(md, gpr_free, ud2);
GPR_ASSERT(grpc_mdelem_get_user_data(md, gpr_free) == ud1);
@@ -312,11 +284,8 @@ static void test_user_data_works(void) {
}
static void verify_ascii_header_size(grpc_exec_ctx *exec_ctx, const char *key,
- const char *value, bool intern_key,
- bool intern_value) {
- grpc_mdelem elem = grpc_mdelem_from_slices(
- exec_ctx, maybe_intern(grpc_slice_from_static_string(key), intern_key),
- maybe_intern(grpc_slice_from_static_string(value), intern_value));
+ const char *value) {
+ grpc_mdelem *elem = grpc_mdelem_from_strings(exec_ctx, key, value);
size_t elem_size = grpc_mdelem_get_size_in_hpack_table(elem);
size_t expected_size = 32 + strlen(key) + strlen(value);
GPR_ASSERT(expected_size == elem_size);
@@ -324,13 +293,10 @@ static void verify_ascii_header_size(grpc_exec_ctx *exec_ctx, const char *key,
}
static void verify_binary_header_size(grpc_exec_ctx *exec_ctx, const char *key,
- const uint8_t *value, size_t value_len,
- bool intern_key, bool intern_value) {
- grpc_mdelem elem = grpc_mdelem_from_slices(
- exec_ctx, maybe_intern(grpc_slice_from_static_string(key), intern_key),
- maybe_intern(grpc_slice_from_static_buffer(value, value_len),
- intern_value));
- GPR_ASSERT(grpc_is_binary_header(GRPC_MDKEY(elem)));
+ const uint8_t *value, size_t value_len) {
+ grpc_mdelem *elem =
+ grpc_mdelem_from_string_and_buffer(exec_ctx, key, value, value_len);
+ GPR_ASSERT(grpc_is_binary_header(key, strlen(key)));
size_t elem_size = grpc_mdelem_get_size_in_hpack_table(elem);
grpc_slice value_slice =
grpc_slice_from_copied_buffer((const char *)value, value_len);
@@ -343,9 +309,8 @@ static void verify_binary_header_size(grpc_exec_ctx *exec_ctx, const char *key,
}
#define BUFFER_SIZE 64
-static void test_mdelem_sizes_in_hpack(bool intern_key, bool intern_value) {
- gpr_log(GPR_INFO, "test_mdelem_size: intern_key=%d intern_value=%d",
- intern_key, intern_value);
+static void test_mdelem_sizes_in_hpack(void) {
+ LOG_TEST("test_mdelem_size");
grpc_init();
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -354,44 +319,19 @@ static void test_mdelem_sizes_in_hpack(bool intern_key, bool intern_value) {
binary_value[i] = i;
}
- verify_ascii_header_size(&exec_ctx, "hello", "world", intern_key,
- intern_value);
+ verify_ascii_header_size(&exec_ctx, "hello", "world");
verify_ascii_header_size(&exec_ctx, "hello",
- "worldxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", intern_key,
- intern_value);
- verify_ascii_header_size(&exec_ctx, ":scheme", "http", intern_key,
- intern_value);
+ "worldxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
+ verify_ascii_header_size(&exec_ctx, ":scheme", "http");
for (uint8_t i = 0; i < BUFFER_SIZE; i++) {
- verify_binary_header_size(&exec_ctx, "hello-bin", binary_value, i,
- intern_key, intern_value);
+ verify_binary_header_size(&exec_ctx, "hello-bin", binary_value, i);
}
- grpc_exec_ctx_finish(&exec_ctx);
- grpc_shutdown();
-}
-
-static void test_copied_static_metadata(bool dup_key, bool dup_value) {
- gpr_log(GPR_INFO, "test_static_metadata: dup_key=%d dup_value=%d", dup_key,
- dup_value);
- grpc_init();
- grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-
- for (size_t i = 0; i < GRPC_STATIC_MDELEM_COUNT; i++) {
- grpc_mdelem p = GRPC_MAKE_MDELEM(&grpc_static_mdelem_table[i],
- GRPC_MDELEM_STORAGE_STATIC);
- grpc_mdelem q =
- grpc_mdelem_from_slices(&exec_ctx, maybe_dup(GRPC_MDKEY(p), dup_key),
- maybe_dup(GRPC_MDVALUE(p), dup_value));
- GPR_ASSERT(grpc_mdelem_eq(p, q));
- if (dup_key || dup_value) {
- GPR_ASSERT(p.payload != q.payload);
- } else {
- GPR_ASSERT(p.payload == q.payload);
- }
- GRPC_MDELEM_UNREF(&exec_ctx, p);
- GRPC_MDELEM_UNREF(&exec_ctx, q);
- }
+ const char *static_metadata = grpc_static_metadata_strings[0];
+ memcpy(binary_value, static_metadata, strlen(static_metadata));
+ verify_binary_header_size(&exec_ctx, "hello-bin", binary_value,
+ strlen(static_metadata));
grpc_exec_ctx_finish(&exec_ctx);
grpc_shutdown();
@@ -400,18 +340,15 @@ static void test_copied_static_metadata(bool dup_key, bool dup_value) {
int main(int argc, char **argv) {
grpc_test_init(argc, argv);
test_no_op();
- for (int k = 0; k <= 1; k++) {
- for (int v = 0; v <= 1; v++) {
- test_create_metadata(k, v);
- test_create_many_ephemeral_metadata(k, v);
- test_identity_laws(k, v);
- test_spin_creating_the_same_thing(k, v);
- test_mdelem_sizes_in_hpack(k, v);
- test_copied_static_metadata(k, v);
- }
- }
+ test_create_string();
+ test_create_metadata();
+ test_create_many_ephemeral_metadata();
test_create_many_persistant_metadata();
+ test_spin_creating_the_same_thing();
test_things_stick_around();
+ test_slices_work();
+ test_base64_and_huffman_works();
test_user_data_works();
+ test_mdelem_sizes_in_hpack();
return 0;
}
diff --git a/test/core/transport/timeout_encoding_test.c b/test/core/transport/timeout_encoding_test.c
index 10e1804995..b6004af7b4 100644
--- a/test/core/transport/timeout_encoding_test.c
+++ b/test/core/transport/timeout_encoding_test.c
@@ -88,8 +88,7 @@ void test_encoding(void) {
static void assert_decodes_as(const char *buffer, gpr_timespec expected) {
gpr_timespec got;
gpr_log(GPR_INFO, "check decoding '%s'", buffer);
- GPR_ASSERT(1 == grpc_http2_decode_timeout(
- grpc_slice_from_static_string(buffer), &got));
+ GPR_ASSERT(1 == grpc_http2_decode_timeout(buffer, &got));
GPR_ASSERT(0 == gpr_time_cmp(got, expected));
}
@@ -135,23 +134,18 @@ void test_decoding(void) {
assert_decodes_as("9999999999S", gpr_inf_future(GPR_TIMESPAN));
}
-static void assert_decoding_fails(const char *s) {
- gpr_timespec x;
- GPR_ASSERT(0 ==
- grpc_http2_decode_timeout(grpc_slice_from_static_string(s), &x));
-}
-
void test_decoding_fails(void) {
+ gpr_timespec x;
LOG_TEST("test_decoding_fails");
- assert_decoding_fails("");
- assert_decoding_fails(" ");
- assert_decoding_fails("x");
- assert_decoding_fails("1");
- assert_decoding_fails("1x");
- assert_decoding_fails("1ux");
- assert_decoding_fails("!");
- assert_decoding_fails("n1");
- assert_decoding_fails("-1u");
+ GPR_ASSERT(0 == grpc_http2_decode_timeout("", &x));
+ GPR_ASSERT(0 == grpc_http2_decode_timeout(" ", &x));
+ GPR_ASSERT(0 == grpc_http2_decode_timeout("x", &x));
+ GPR_ASSERT(0 == grpc_http2_decode_timeout("1", &x));
+ GPR_ASSERT(0 == grpc_http2_decode_timeout("1x", &x));
+ GPR_ASSERT(0 == grpc_http2_decode_timeout("1ux", &x));
+ GPR_ASSERT(0 == grpc_http2_decode_timeout("!", &x));
+ GPR_ASSERT(0 == grpc_http2_decode_timeout("n1", &x));
+ GPR_ASSERT(0 == grpc_http2_decode_timeout("-1u", &x));
}
int main(int argc, char **argv) {
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-27 08:18:21 +0000