Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 1 | /* |
| 2 | * |
Craig Tiller | 0605995 | 2015-02-18 08:34:56 -0800 | [diff] [blame] | 3 | * Copyright 2015, Google Inc. |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 4 | * All rights reserved. |
| 5 | * |
| 6 | * Redistribution and use in source and binary forms, with or without |
| 7 | * modification, are permitted provided that the following conditions are |
| 8 | * met: |
| 9 | * |
| 10 | * * Redistributions of source code must retain the above copyright |
| 11 | * notice, this list of conditions and the following disclaimer. |
| 12 | * * Redistributions in binary form must reproduce the above |
| 13 | * copyright notice, this list of conditions and the following disclaimer |
| 14 | * in the documentation and/or other materials provided with the |
| 15 | * distribution. |
| 16 | * * Neither the name of Google Inc. nor the names of its |
| 17 | * contributors may be used to endorse or promote products derived from |
| 18 | * this software without specific prior written permission. |
| 19 | * |
| 20 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 21 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 22 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 23 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 24 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 25 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 26 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 27 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 28 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 29 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 30 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 31 | * |
| 32 | */ |
| 33 | |
| 34 | #include "src/core/transport/chttp2/stream_encoder.h" |
| 35 | |
| 36 | #include <stdio.h> |
| 37 | |
Craig Tiller | 485d776 | 2015-01-23 12:54:05 -0800 | [diff] [blame] | 38 | #include "src/core/support/string.h" |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 39 | #include "src/core/transport/chttp2/hpack_parser.h" |
| 40 | #include <grpc/support/alloc.h> |
| 41 | #include <grpc/support/log.h> |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 42 | #include "test/core/util/parse_hexstring.h" |
| 43 | #include "test/core/util/slice_splitter.h" |
| 44 | #include "test/core/util/test_config.h" |
| 45 | |
| 46 | #define TEST(x) run_test(x, #x) |
| 47 | |
| 48 | grpc_mdctx *g_mdctx; |
| 49 | grpc_chttp2_hpack_compressor g_compressor; |
| 50 | int g_failure = 0; |
| 51 | grpc_stream_op_buffer g_sopb; |
| 52 | |
Craig Tiller | bd22271 | 2015-04-17 16:09:40 -0700 | [diff] [blame] | 53 | void **to_delete = NULL; |
| 54 | int num_to_delete = 0; |
| 55 | int cap_to_delete = 0; |
| 56 | |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 57 | static gpr_slice create_test_slice(size_t length) { |
| 58 | gpr_slice slice = gpr_slice_malloc(length); |
| 59 | size_t i; |
| 60 | for (i = 0; i < length; i++) { |
| 61 | GPR_SLICE_START_PTR(slice)[i] = i; |
| 62 | } |
| 63 | return slice; |
| 64 | } |
| 65 | |
| 66 | /* verify that the output generated by encoding the stream matches the |
| 67 | hexstring passed in */ |
| 68 | static void verify_sopb(size_t window_available, int eof, |
| 69 | size_t expect_window_used, const char *expected) { |
| 70 | gpr_slice_buffer output; |
ctiller | 00297df | 2015-01-12 11:23:09 -0800 | [diff] [blame] | 71 | grpc_stream_op_buffer encops; |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 72 | gpr_slice merged; |
| 73 | gpr_slice expect = parse_hexstring(expected); |
| 74 | gpr_slice_buffer_init(&output); |
ctiller | 00297df | 2015-01-12 11:23:09 -0800 | [diff] [blame] | 75 | grpc_sopb_init(&encops); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 76 | GPR_ASSERT(expect_window_used == |
ctiller | 00297df | 2015-01-12 11:23:09 -0800 | [diff] [blame] | 77 | grpc_chttp2_preencode(g_sopb.ops, &g_sopb.nops, window_available, |
| 78 | &encops)); |
| 79 | grpc_chttp2_encode(encops.ops, encops.nops, eof, 0xdeadbeef, &g_compressor, |
| 80 | &output); |
| 81 | encops.nops = 0; |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 82 | merged = grpc_slice_merge(output.slices, output.count); |
| 83 | gpr_slice_buffer_destroy(&output); |
ctiller | 00297df | 2015-01-12 11:23:09 -0800 | [diff] [blame] | 84 | grpc_sopb_destroy(&encops); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 85 | |
| 86 | if (0 != gpr_slice_cmp(merged, expect)) { |
| 87 | char *expect_str = |
| 88 | gpr_hexdump((char *)GPR_SLICE_START_PTR(expect), |
| 89 | GPR_SLICE_LENGTH(expect), GPR_HEXDUMP_PLAINTEXT); |
| 90 | char *got_str = |
| 91 | gpr_hexdump((char *)GPR_SLICE_START_PTR(merged), |
| 92 | GPR_SLICE_LENGTH(merged), GPR_HEXDUMP_PLAINTEXT); |
| 93 | gpr_log(GPR_ERROR, "mismatched output for %s", expected); |
| 94 | gpr_log(GPR_ERROR, "EXPECT: %s", expect_str); |
| 95 | gpr_log(GPR_ERROR, "GOT: %s", got_str); |
| 96 | gpr_free(expect_str); |
| 97 | gpr_free(got_str); |
| 98 | g_failure = 1; |
| 99 | } |
| 100 | |
| 101 | gpr_slice_unref(merged); |
| 102 | gpr_slice_unref(expect); |
| 103 | } |
| 104 | |
| 105 | static void assert_result_ok(void *user_data, grpc_op_error error) { |
| 106 | GPR_ASSERT(error == GRPC_OP_OK); |
| 107 | } |
| 108 | |
Craig Tiller | 32946d3 | 2015-01-15 11:37:30 -0800 | [diff] [blame] | 109 | static void test_small_data_framing(void) { |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 110 | grpc_sopb_add_no_op(&g_sopb); |
| 111 | verify_sopb(10, 0, 0, ""); |
| 112 | |
| 113 | grpc_sopb_add_flow_ctl_cb(&g_sopb, assert_result_ok, NULL); |
| 114 | grpc_sopb_add_slice(&g_sopb, create_test_slice(3)); |
| 115 | verify_sopb(10, 0, 3, "000003 0000 deadbeef 000102"); |
| 116 | |
| 117 | grpc_sopb_add_slice(&g_sopb, create_test_slice(4)); |
| 118 | verify_sopb(10, 0, 4, "000004 0000 deadbeef 00010203"); |
| 119 | |
| 120 | grpc_sopb_add_slice(&g_sopb, create_test_slice(3)); |
| 121 | grpc_sopb_add_slice(&g_sopb, create_test_slice(4)); |
| 122 | verify_sopb(10, 0, 7, "000007 0000 deadbeef 000102 00010203"); |
| 123 | |
| 124 | grpc_sopb_add_slice(&g_sopb, create_test_slice(0)); |
| 125 | grpc_sopb_add_slice(&g_sopb, create_test_slice(0)); |
| 126 | grpc_sopb_add_slice(&g_sopb, create_test_slice(0)); |
| 127 | grpc_sopb_add_slice(&g_sopb, create_test_slice(0)); |
| 128 | grpc_sopb_add_slice(&g_sopb, create_test_slice(3)); |
| 129 | verify_sopb(10, 0, 3, "000003 0000 deadbeef 000102"); |
| 130 | |
| 131 | verify_sopb(10, 1, 0, "000000 0001 deadbeef"); |
| 132 | |
| 133 | grpc_sopb_add_begin_message(&g_sopb, 255, 0); |
| 134 | verify_sopb(10, 0, 5, "000005 0000 deadbeef 00000000ff"); |
| 135 | } |
| 136 | |
Craig Tiller | 9c1043e | 2015-04-16 16:20:38 -0700 | [diff] [blame] | 137 | static void add_sopb_headers(int n, ...) { |
| 138 | int i; |
| 139 | grpc_metadata_batch b; |
| 140 | va_list l; |
| 141 | grpc_linked_mdelem *e = gpr_malloc(sizeof(*e) * n); |
| 142 | |
Craig Tiller | bd22271 | 2015-04-17 16:09:40 -0700 | [diff] [blame] | 143 | grpc_metadata_batch_init(&b); |
| 144 | |
Craig Tiller | 9c1043e | 2015-04-16 16:20:38 -0700 | [diff] [blame] | 145 | va_start(l, n); |
| 146 | for (i = 0; i < n; i++) { |
| 147 | char *key = va_arg(l, char *); |
| 148 | char *value = va_arg(l, char *); |
| 149 | if (i) { |
Craig Tiller | 5c019ae | 2015-04-17 16:46:53 -0700 | [diff] [blame] | 150 | e[i - 1].next = &e[i]; |
| 151 | e[i].prev = &e[i - 1]; |
Craig Tiller | 9c1043e | 2015-04-16 16:20:38 -0700 | [diff] [blame] | 152 | } |
| 153 | e[i].md = grpc_mdelem_from_strings(g_mdctx, key, value); |
| 154 | } |
| 155 | e[0].prev = NULL; |
Craig Tiller | 5c019ae | 2015-04-17 16:46:53 -0700 | [diff] [blame] | 156 | e[n - 1].next = NULL; |
Craig Tiller | 9c1043e | 2015-04-16 16:20:38 -0700 | [diff] [blame] | 157 | va_end(l); |
| 158 | |
Craig Tiller | bd22271 | 2015-04-17 16:09:40 -0700 | [diff] [blame] | 159 | b.list.head = &e[0]; |
Craig Tiller | 5c019ae | 2015-04-17 16:46:53 -0700 | [diff] [blame] | 160 | b.list.tail = &e[n - 1]; |
Craig Tiller | bd22271 | 2015-04-17 16:09:40 -0700 | [diff] [blame] | 161 | |
| 162 | if (cap_to_delete == num_to_delete) { |
Craig Tiller | 5c019ae | 2015-04-17 16:46:53 -0700 | [diff] [blame] | 163 | cap_to_delete = GPR_MAX(2 * cap_to_delete, 1000); |
Craig Tiller | bd22271 | 2015-04-17 16:09:40 -0700 | [diff] [blame] | 164 | to_delete = gpr_realloc(to_delete, sizeof(*to_delete) * cap_to_delete); |
| 165 | } |
| 166 | to_delete[num_to_delete++] = e; |
| 167 | |
Craig Tiller | 9c1043e | 2015-04-16 16:20:38 -0700 | [diff] [blame] | 168 | grpc_sopb_add_metadata(&g_sopb, b); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 169 | } |
| 170 | |
Craig Tiller | 32946d3 | 2015-01-15 11:37:30 -0800 | [diff] [blame] | 171 | static void test_basic_headers(void) { |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 172 | int i; |
| 173 | |
Craig Tiller | 9c1043e | 2015-04-16 16:20:38 -0700 | [diff] [blame] | 174 | add_sopb_headers(1, "a", "a"); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 175 | verify_sopb(0, 0, 0, "000005 0104 deadbeef 40 0161 0161"); |
| 176 | |
Craig Tiller | 9c1043e | 2015-04-16 16:20:38 -0700 | [diff] [blame] | 177 | add_sopb_headers(1, "a", "a"); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 178 | verify_sopb(0, 0, 0, "000001 0104 deadbeef be"); |
| 179 | |
Craig Tiller | 9c1043e | 2015-04-16 16:20:38 -0700 | [diff] [blame] | 180 | add_sopb_headers(1, "a", "a"); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 181 | verify_sopb(0, 0, 0, "000001 0104 deadbeef be"); |
| 182 | |
Craig Tiller | 9c1043e | 2015-04-16 16:20:38 -0700 | [diff] [blame] | 183 | add_sopb_headers(2, "a", "a", "b", "c"); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 184 | verify_sopb(0, 0, 0, "000006 0104 deadbeef be 40 0162 0163"); |
| 185 | |
Craig Tiller | 9c1043e | 2015-04-16 16:20:38 -0700 | [diff] [blame] | 186 | add_sopb_headers(2, "a", "a", "b", "c"); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 187 | verify_sopb(0, 0, 0, "000002 0104 deadbeef bf be"); |
| 188 | |
Craig Tiller | 9c1043e | 2015-04-16 16:20:38 -0700 | [diff] [blame] | 189 | add_sopb_headers(1, "a", "d"); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 190 | verify_sopb(0, 0, 0, "000004 0104 deadbeef 7f 00 0164"); |
| 191 | |
| 192 | /* flush out what's there to make a few values look very popular */ |
| 193 | for (i = 0; i < 350; i++) { |
Craig Tiller | 9c1043e | 2015-04-16 16:20:38 -0700 | [diff] [blame] | 194 | add_sopb_headers(3, "a", "a", "b", "c", "a", "d"); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 195 | verify_sopb(0, 0, 0, "000003 0104 deadbeef c0 bf be"); |
| 196 | } |
| 197 | |
Craig Tiller | 9c1043e | 2015-04-16 16:20:38 -0700 | [diff] [blame] | 198 | add_sopb_headers(2, "a", "a", "k", "v"); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 199 | verify_sopb(0, 0, 0, "000006 0104 deadbeef c0 00 016b 0176"); |
| 200 | |
Craig Tiller | 9c1043e | 2015-04-16 16:20:38 -0700 | [diff] [blame] | 201 | add_sopb_headers(1, "a", "v"); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 202 | /* this could be 000004 0104 deadbeef 0f 30 0176 also */ |
| 203 | verify_sopb(0, 0, 0, "000004 0104 deadbeef 0f 2f 0176"); |
| 204 | } |
| 205 | |
| 206 | static void encode_int_to_str(int i, char *p) { |
| 207 | p[0] = 'a' + i % 26; |
| 208 | i /= 26; |
| 209 | GPR_ASSERT(i < 26); |
| 210 | p[1] = 'a' + i; |
| 211 | p[2] = 0; |
| 212 | } |
| 213 | |
Craig Tiller | 32946d3 | 2015-01-15 11:37:30 -0800 | [diff] [blame] | 214 | static void test_decode_table_overflow(void) { |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 215 | int i; |
| 216 | char key[3], value[3]; |
Craig Tiller | 28214ea | 2015-01-23 15:17:07 -0800 | [diff] [blame] | 217 | char *expect; |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 218 | |
| 219 | for (i = 0; i < 114; i++) { |
| 220 | if (i > 0) { |
Craig Tiller | 9c1043e | 2015-04-16 16:20:38 -0700 | [diff] [blame] | 221 | add_sopb_headers(1, "aa", "ba"); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 222 | } |
| 223 | |
| 224 | encode_int_to_str(i, key); |
| 225 | encode_int_to_str(i + 1, value); |
| 226 | |
| 227 | if (i + 61 >= 127) { |
Craig Tiller | 28214ea | 2015-01-23 15:17:07 -0800 | [diff] [blame] | 228 | gpr_asprintf(&expect, |
Craig Tiller | 5c019ae | 2015-04-17 16:46:53 -0700 | [diff] [blame] | 229 | "000002 0104 deadbeef ff%02x 000007 0104 deadbeef 40 " |
| 230 | "02%02x%02x 02%02x%02x", |
Craig Tiller | 28214ea | 2015-01-23 15:17:07 -0800 | [diff] [blame] | 231 | i + 61 - 127, key[0], key[1], value[0], value[1]); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 232 | } else if (i > 0) { |
Craig Tiller | 28214ea | 2015-01-23 15:17:07 -0800 | [diff] [blame] | 233 | gpr_asprintf(&expect, |
Craig Tiller | 5c019ae | 2015-04-17 16:46:53 -0700 | [diff] [blame] | 234 | "000001 0104 deadbeef %02x 000007 0104 deadbeef 40 " |
| 235 | "02%02x%02x 02%02x%02x", |
Craig Tiller | 28214ea | 2015-01-23 15:17:07 -0800 | [diff] [blame] | 236 | 0x80 + 61 + i, key[0], key[1], value[0], value[1]); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 237 | } else { |
Craig Tiller | 28214ea | 2015-01-23 15:17:07 -0800 | [diff] [blame] | 238 | gpr_asprintf(&expect, "000007 0104 deadbeef 40 02%02x%02x 02%02x%02x", |
| 239 | key[0], key[1], value[0], value[1]); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 240 | } |
| 241 | |
Craig Tiller | 9c1043e | 2015-04-16 16:20:38 -0700 | [diff] [blame] | 242 | add_sopb_headers(1, key, value); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 243 | verify_sopb(0, 0, 0, expect); |
Craig Tiller | 28214ea | 2015-01-23 15:17:07 -0800 | [diff] [blame] | 244 | gpr_free(expect); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 245 | } |
| 246 | |
| 247 | /* if the above passes, then we must have just knocked this pair out of the |
| 248 | decoder stack, and so we'll be forced to re-encode it */ |
Craig Tiller | 9c1043e | 2015-04-16 16:20:38 -0700 | [diff] [blame] | 249 | add_sopb_headers(1, "aa", "ba"); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 250 | verify_sopb(0, 0, 0, "000007 0104 deadbeef 40 026161 026261"); |
| 251 | } |
| 252 | |
| 253 | static void randstr(char *p, int bufsz) { |
| 254 | int i; |
| 255 | int len = 1 + rand() % bufsz; |
| 256 | for (i = 0; i < len; i++) { |
| 257 | p[i] = 'a' + rand() % 26; |
| 258 | } |
| 259 | p[len] = 0; |
| 260 | } |
| 261 | |
| 262 | typedef struct { |
| 263 | char key[300]; |
| 264 | char value[300]; |
| 265 | int got_hdr; |
| 266 | } test_decode_random_header_state; |
| 267 | |
| 268 | static void chk_hdr(void *p, grpc_mdelem *el) { |
| 269 | test_decode_random_header_state *st = p; |
| 270 | GPR_ASSERT(0 == gpr_slice_str_cmp(el->key->slice, st->key)); |
| 271 | GPR_ASSERT(0 == gpr_slice_str_cmp(el->value->slice, st->value)); |
| 272 | st->got_hdr = 1; |
| 273 | grpc_mdelem_unref(el); |
| 274 | } |
| 275 | |
| 276 | static void test_decode_random_headers_inner(int max_len) { |
| 277 | int i; |
| 278 | test_decode_random_header_state st; |
| 279 | gpr_slice_buffer output; |
| 280 | gpr_slice merged; |
ctiller | 00297df | 2015-01-12 11:23:09 -0800 | [diff] [blame] | 281 | grpc_stream_op_buffer encops; |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 282 | grpc_chttp2_hpack_parser parser; |
| 283 | |
| 284 | grpc_chttp2_hpack_parser_init(&parser, g_mdctx); |
ctiller | 00297df | 2015-01-12 11:23:09 -0800 | [diff] [blame] | 285 | grpc_sopb_init(&encops); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 286 | |
| 287 | gpr_log(GPR_INFO, "max_len = %d", max_len); |
| 288 | |
ctiller | 00297df | 2015-01-12 11:23:09 -0800 | [diff] [blame] | 289 | for (i = 0; i < 10000; i++) { |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 290 | randstr(st.key, max_len); |
| 291 | randstr(st.value, max_len); |
| 292 | |
Craig Tiller | 9c1043e | 2015-04-16 16:20:38 -0700 | [diff] [blame] | 293 | add_sopb_headers(1, st.key, st.value); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 294 | gpr_slice_buffer_init(&output); |
ctiller | 00297df | 2015-01-12 11:23:09 -0800 | [diff] [blame] | 295 | GPR_ASSERT(0 == |
| 296 | grpc_chttp2_preencode(g_sopb.ops, &g_sopb.nops, 0, &encops)); |
| 297 | grpc_chttp2_encode(encops.ops, encops.nops, 0, 0xdeadbeef, &g_compressor, |
| 298 | &output); |
| 299 | encops.nops = 0; |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 300 | merged = grpc_slice_merge(output.slices, output.count); |
| 301 | gpr_slice_buffer_destroy(&output); |
| 302 | |
| 303 | st.got_hdr = 0; |
| 304 | parser.on_header = chk_hdr; |
| 305 | parser.on_header_user_data = &st; |
| 306 | grpc_chttp2_hpack_parser_parse(&parser, GPR_SLICE_START_PTR(merged) + 9, |
| 307 | GPR_SLICE_END_PTR(merged)); |
| 308 | GPR_ASSERT(st.got_hdr); |
| 309 | |
| 310 | gpr_slice_unref(merged); |
| 311 | } |
| 312 | |
| 313 | grpc_chttp2_hpack_parser_destroy(&parser); |
ctiller | 00297df | 2015-01-12 11:23:09 -0800 | [diff] [blame] | 314 | grpc_sopb_destroy(&encops); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 315 | } |
| 316 | |
Craig Tiller | 3eef2c4 | 2015-01-15 11:37:54 -0800 | [diff] [blame] | 317 | #define DECL_TEST_DECODE_RANDOM_HEADERS(n) \ |
Craig Tiller | 32946d3 | 2015-01-15 11:37:30 -0800 | [diff] [blame] | 318 | static void test_decode_random_headers_##n(void) { \ |
Craig Tiller | 3eef2c4 | 2015-01-15 11:37:54 -0800 | [diff] [blame] | 319 | test_decode_random_headers_inner(n); \ |
| 320 | } \ |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 321 | int keeps_formatting_correct_##n |
| 322 | |
| 323 | DECL_TEST_DECODE_RANDOM_HEADERS(1); |
| 324 | DECL_TEST_DECODE_RANDOM_HEADERS(2); |
| 325 | DECL_TEST_DECODE_RANDOM_HEADERS(3); |
| 326 | DECL_TEST_DECODE_RANDOM_HEADERS(5); |
| 327 | DECL_TEST_DECODE_RANDOM_HEADERS(8); |
| 328 | DECL_TEST_DECODE_RANDOM_HEADERS(13); |
| 329 | DECL_TEST_DECODE_RANDOM_HEADERS(21); |
| 330 | DECL_TEST_DECODE_RANDOM_HEADERS(34); |
| 331 | DECL_TEST_DECODE_RANDOM_HEADERS(55); |
| 332 | DECL_TEST_DECODE_RANDOM_HEADERS(89); |
| 333 | DECL_TEST_DECODE_RANDOM_HEADERS(144); |
| 334 | |
| 335 | static void run_test(void (*test)(), const char *name) { |
| 336 | gpr_log(GPR_INFO, "RUN TEST: %s", name); |
| 337 | g_mdctx = grpc_mdctx_create_with_seed(0); |
| 338 | grpc_chttp2_hpack_compressor_init(&g_compressor, g_mdctx); |
| 339 | grpc_sopb_init(&g_sopb); |
| 340 | test(); |
| 341 | grpc_chttp2_hpack_compressor_destroy(&g_compressor); |
Craig Tiller | 9be83ee | 2015-02-18 14:16:15 -0800 | [diff] [blame] | 342 | grpc_mdctx_unref(g_mdctx); |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 343 | grpc_sopb_destroy(&g_sopb); |
| 344 | } |
| 345 | |
| 346 | int main(int argc, char **argv) { |
Craig Tiller | bd22271 | 2015-04-17 16:09:40 -0700 | [diff] [blame] | 347 | int i; |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 348 | grpc_test_init(argc, argv); |
| 349 | TEST(test_small_data_framing); |
| 350 | TEST(test_basic_headers); |
| 351 | TEST(test_decode_table_overflow); |
| 352 | TEST(test_decode_random_headers_1); |
| 353 | TEST(test_decode_random_headers_2); |
| 354 | TEST(test_decode_random_headers_3); |
| 355 | TEST(test_decode_random_headers_5); |
| 356 | TEST(test_decode_random_headers_8); |
| 357 | TEST(test_decode_random_headers_13); |
| 358 | TEST(test_decode_random_headers_21); |
| 359 | TEST(test_decode_random_headers_34); |
| 360 | TEST(test_decode_random_headers_55); |
| 361 | TEST(test_decode_random_headers_89); |
| 362 | TEST(test_decode_random_headers_144); |
Craig Tiller | bd22271 | 2015-04-17 16:09:40 -0700 | [diff] [blame] | 363 | for (i = 0; i < num_to_delete; i++) { |
| 364 | gpr_free(to_delete[i]); |
| 365 | } |
Nicolas Noble | b7ebd3b | 2014-11-26 16:33:03 -0800 | [diff] [blame] | 366 | return g_failure; |
Craig Tiller | 190d360 | 2015-02-18 09:23:38 -0800 | [diff] [blame] | 367 | } |