1 /*
2 *
3 * Copyright 2015 gRPC authors.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 */
18
19 #include <grpc/impl/codegen/port_platform.h>
20
21 #include <limits.h>
22 #include <string.h>
23
24 #include <grpc/grpc.h>
25 #include <grpc/support/alloc.h>
26 #include <grpc/support/log.h>
27
28 #include "src/core/lib/gpr/host_port.h"
29 #include "test/core/end2end/cq_verifier.h"
30 #include "test/core/util/port.h"
31 #include "test/core/util/test_config.h"
32
tag(intptr_t i)33 static void* tag(intptr_t i) { return (void*)i; }
34
35 struct test_state {
36 int is_client;
37 grpc_channel* chan;
38 grpc_call* call;
39 gpr_timespec deadline;
40 grpc_completion_queue* cq;
41 cq_verifier* cqv;
42 grpc_op ops[6];
43 grpc_metadata_array initial_metadata_recv;
44 grpc_metadata_array trailing_metadata_recv;
45 grpc_status_code status;
46 grpc_slice details;
47 grpc_call* server_call;
48 grpc_server* server;
49 grpc_metadata_array server_initial_metadata_recv;
50 grpc_call_details call_details;
51 };
52
53 static struct test_state g_state;
54
prepare_test(int is_client)55 static void prepare_test(int is_client) {
56 int port = grpc_pick_unused_port_or_die();
57 char* server_hostport;
58 grpc_op* op;
59 g_state.is_client = is_client;
60 grpc_metadata_array_init(&g_state.initial_metadata_recv);
61 grpc_metadata_array_init(&g_state.trailing_metadata_recv);
62 g_state.deadline = grpc_timeout_seconds_to_deadline(5);
63 g_state.cq = grpc_completion_queue_create_for_next(nullptr);
64 g_state.cqv = cq_verifier_create(g_state.cq);
65 g_state.details = grpc_empty_slice();
66 memset(g_state.ops, 0, sizeof(g_state.ops));
67
68 if (is_client) {
69 /* create a call, channel to a non existant server */
70 g_state.chan =
71 grpc_insecure_channel_create("nonexistant:54321", nullptr, nullptr);
72 grpc_slice host = grpc_slice_from_static_string("nonexistant");
73 g_state.call = grpc_channel_create_call(
74 g_state.chan, nullptr, GRPC_PROPAGATE_DEFAULTS, g_state.cq,
75 grpc_slice_from_static_string("/Foo"), &host, g_state.deadline,
76 nullptr);
77 } else {
78 g_state.server = grpc_server_create(nullptr, nullptr);
79 grpc_server_register_completion_queue(g_state.server, g_state.cq, nullptr);
80 gpr_join_host_port(&server_hostport, "0.0.0.0", port);
81 grpc_server_add_insecure_http2_port(g_state.server, server_hostport);
82 grpc_server_start(g_state.server);
83 gpr_free(server_hostport);
84 gpr_join_host_port(&server_hostport, "localhost", port);
85 g_state.chan =
86 grpc_insecure_channel_create(server_hostport, nullptr, nullptr);
87 gpr_free(server_hostport);
88 grpc_slice host = grpc_slice_from_static_string("bar");
89 g_state.call = grpc_channel_create_call(
90 g_state.chan, nullptr, GRPC_PROPAGATE_DEFAULTS, g_state.cq,
91 grpc_slice_from_static_string("/Foo"), &host, g_state.deadline,
92 nullptr);
93 grpc_metadata_array_init(&g_state.server_initial_metadata_recv);
94 grpc_call_details_init(&g_state.call_details);
95 op = g_state.ops;
96 op->op = GRPC_OP_SEND_INITIAL_METADATA;
97 op->data.send_initial_metadata.count = 0;
98 op->flags = GRPC_INITIAL_METADATA_WAIT_FOR_READY;
99 op->reserved = nullptr;
100 op++;
101 GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(g_state.call, g_state.ops,
102 (size_t)(op - g_state.ops),
103 tag(1), nullptr));
104 GPR_ASSERT(GRPC_CALL_OK ==
105 grpc_server_request_call(g_state.server, &g_state.server_call,
106 &g_state.call_details,
107 &g_state.server_initial_metadata_recv,
108 g_state.cq, g_state.cq, tag(101)));
109 CQ_EXPECT_COMPLETION(g_state.cqv, tag(101), 1);
110 CQ_EXPECT_COMPLETION(g_state.cqv, tag(1), 1);
111 cq_verify(g_state.cqv);
112 }
113 }
114
cleanup_test()115 static void cleanup_test() {
116 grpc_completion_queue* shutdown_cq;
117 grpc_call_unref(g_state.call);
118 cq_verifier_destroy(g_state.cqv);
119 grpc_channel_destroy(g_state.chan);
120 grpc_slice_unref(g_state.details);
121 grpc_metadata_array_destroy(&g_state.initial_metadata_recv);
122 grpc_metadata_array_destroy(&g_state.trailing_metadata_recv);
123
124 if (!g_state.is_client) {
125 shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
126 grpc_call_unref(g_state.server_call);
127 grpc_server_shutdown_and_notify(g_state.server, shutdown_cq, tag(1000));
128 GPR_ASSERT(grpc_completion_queue_pluck(shutdown_cq, tag(1000),
129 grpc_timeout_seconds_to_deadline(5),
130 nullptr)
131 .type == GRPC_OP_COMPLETE);
132 grpc_completion_queue_destroy(shutdown_cq);
133 grpc_server_destroy(g_state.server);
134 grpc_call_details_destroy(&g_state.call_details);
135 grpc_metadata_array_destroy(&g_state.server_initial_metadata_recv);
136 }
137 grpc_completion_queue_shutdown(g_state.cq);
138 while (grpc_completion_queue_next(g_state.cq,
139 gpr_inf_future(GPR_CLOCK_REALTIME), nullptr)
140 .type != GRPC_QUEUE_SHUTDOWN)
141 ;
142 grpc_completion_queue_destroy(g_state.cq);
143 }
144
test_non_null_reserved_on_start_batch()145 static void test_non_null_reserved_on_start_batch() {
146 gpr_log(GPR_INFO, "test_non_null_reserved_on_start_batch");
147
148 prepare_test(1);
149 GPR_ASSERT(GRPC_CALL_ERROR ==
150 grpc_call_start_batch(g_state.call, nullptr, 0, nullptr, tag(1)));
151 cleanup_test();
152 }
153
test_non_null_reserved_on_op()154 static void test_non_null_reserved_on_op() {
155 gpr_log(GPR_INFO, "test_non_null_reserved_on_op");
156
157 grpc_op* op;
158 prepare_test(1);
159
160 op = g_state.ops;
161 op->op = GRPC_OP_SEND_INITIAL_METADATA;
162 op->data.send_initial_metadata.count = 0;
163 op->flags = 0;
164 op->reserved = tag(2);
165 op++;
166 GPR_ASSERT(GRPC_CALL_ERROR ==
167 grpc_call_start_batch(g_state.call, g_state.ops,
168 (size_t)(op - g_state.ops), tag(1),
169 nullptr));
170 cleanup_test();
171 }
172
test_send_initial_metadata_more_than_once()173 static void test_send_initial_metadata_more_than_once() {
174 gpr_log(GPR_INFO, "test_send_initial_metadata_more_than_once");
175
176 grpc_op* op;
177 prepare_test(1);
178
179 op = g_state.ops;
180 op->op = GRPC_OP_SEND_INITIAL_METADATA;
181 op->data.send_initial_metadata.count = 0;
182 op->flags = 0;
183 op->reserved = nullptr;
184 op++;
185 GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(g_state.call, g_state.ops,
186 (size_t)(op - g_state.ops),
187 tag(1), nullptr));
188 CQ_EXPECT_COMPLETION(g_state.cqv, tag(1), 0);
189 cq_verify(g_state.cqv);
190
191 op = g_state.ops;
192 op->op = GRPC_OP_SEND_INITIAL_METADATA;
193 op->data.send_initial_metadata.count = 0;
194 op->flags = 0;
195 op->reserved = nullptr;
196 op++;
197 GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
198 grpc_call_start_batch(g_state.call, g_state.ops,
199 (size_t)(op - g_state.ops), tag(1),
200 nullptr));
201 cleanup_test();
202 }
203
test_too_many_metadata()204 static void test_too_many_metadata() {
205 gpr_log(GPR_INFO, "test_too_many_metadata");
206
207 grpc_op* op;
208 prepare_test(1);
209
210 op = g_state.ops;
211 op->op = GRPC_OP_SEND_INITIAL_METADATA;
212 op->data.send_initial_metadata.count = static_cast<size_t>(INT_MAX) + 1;
213 op->flags = 0;
214 op->reserved = nullptr;
215 op++;
216 GPR_ASSERT(GRPC_CALL_ERROR_INVALID_METADATA ==
217 grpc_call_start_batch(g_state.call, g_state.ops,
218 (size_t)(op - g_state.ops), tag(1),
219 nullptr));
220 cleanup_test();
221 }
222
test_send_null_message()223 static void test_send_null_message() {
224 gpr_log(GPR_INFO, "test_send_null_message");
225
226 grpc_op* op;
227 prepare_test(1);
228
229 op = g_state.ops;
230 op->op = GRPC_OP_SEND_INITIAL_METADATA;
231 op->data.send_initial_metadata.count = 0;
232 op->flags = 0;
233 op->reserved = nullptr;
234 op++;
235 op->op = GRPC_OP_SEND_MESSAGE;
236 op->data.send_message.send_message = nullptr;
237 op->flags = 0;
238 op->reserved = nullptr;
239 op++;
240 GPR_ASSERT(GRPC_CALL_ERROR_INVALID_MESSAGE ==
241 grpc_call_start_batch(g_state.call, g_state.ops,
242 (size_t)(op - g_state.ops), tag(1),
243 nullptr));
244 cleanup_test();
245 }
246
test_send_messages_at_the_same_time()247 static void test_send_messages_at_the_same_time() {
248 gpr_log(GPR_INFO, "test_send_messages_at_the_same_time");
249
250 grpc_op* op;
251 grpc_slice request_payload_slice =
252 grpc_slice_from_copied_string("hello world");
253 grpc_byte_buffer* request_payload =
254 grpc_raw_byte_buffer_create(&request_payload_slice, 1);
255 prepare_test(1);
256 op = g_state.ops;
257 op->op = GRPC_OP_SEND_INITIAL_METADATA;
258 op->data.send_initial_metadata.count = 0;
259 op->flags = 0;
260 op->reserved = nullptr;
261 op++;
262 op->op = GRPC_OP_SEND_MESSAGE;
263 op->data.send_message.send_message = request_payload;
264 op->flags = 0;
265 op->reserved = nullptr;
266 op++;
267 op->op = GRPC_OP_SEND_MESSAGE;
268 op->data.send_message.send_message = static_cast<grpc_byte_buffer*>(tag(2));
269 op->flags = 0;
270 op->reserved = nullptr;
271 op++;
272 GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
273 grpc_call_start_batch(g_state.call, g_state.ops,
274 (size_t)(op - g_state.ops), tag(1),
275 nullptr));
276 grpc_byte_buffer_destroy(request_payload);
277 cleanup_test();
278 }
279
test_send_server_status_from_client()280 static void test_send_server_status_from_client() {
281 gpr_log(GPR_INFO, "test_send_server_status_from_client");
282
283 grpc_op* op;
284 prepare_test(1);
285
286 op = g_state.ops;
287 op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
288 op->data.send_status_from_server.trailing_metadata_count = 0;
289 op->data.send_status_from_server.status = GRPC_STATUS_UNIMPLEMENTED;
290 grpc_slice status_details = grpc_slice_from_static_string("xyz");
291 op->data.send_status_from_server.status_details = &status_details;
292 op->flags = 0;
293 op->reserved = nullptr;
294 op++;
295 GPR_ASSERT(GRPC_CALL_ERROR_NOT_ON_CLIENT ==
296 grpc_call_start_batch(g_state.call, g_state.ops,
297 (size_t)(op - g_state.ops), tag(1),
298 nullptr));
299 cleanup_test();
300 }
301
test_receive_initial_metadata_twice_at_client()302 static void test_receive_initial_metadata_twice_at_client() {
303 gpr_log(GPR_INFO, "test_receive_initial_metadata_twice_at_client");
304
305 grpc_op* op;
306 prepare_test(1);
307 op = g_state.ops;
308 op->op = GRPC_OP_RECV_INITIAL_METADATA;
309 op->data.recv_initial_metadata.recv_initial_metadata =
310 &g_state.initial_metadata_recv;
311 op->flags = 0;
312 op->reserved = nullptr;
313 op++;
314 GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(g_state.call, g_state.ops,
315 (size_t)(op - g_state.ops),
316 tag(1), nullptr));
317 CQ_EXPECT_COMPLETION(g_state.cqv, tag(1), 0);
318 cq_verify(g_state.cqv);
319 op = g_state.ops;
320 op->op = GRPC_OP_RECV_INITIAL_METADATA;
321 op->data.recv_initial_metadata.recv_initial_metadata =
322 &g_state.initial_metadata_recv;
323 op->flags = 0;
324 op->reserved = nullptr;
325 op++;
326 GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
327 grpc_call_start_batch(g_state.call, g_state.ops,
328 (size_t)(op - g_state.ops), tag(1),
329 nullptr));
330 cleanup_test();
331 }
332
test_receive_message_with_invalid_flags()333 static void test_receive_message_with_invalid_flags() {
334 gpr_log(GPR_INFO, "test_receive_message_with_invalid_flags");
335
336 grpc_op* op;
337 grpc_byte_buffer* payload = nullptr;
338 prepare_test(1);
339 op = g_state.ops;
340 op->op = GRPC_OP_RECV_MESSAGE;
341 op->data.recv_message.recv_message = &payload;
342 op->flags = 1;
343 op->reserved = nullptr;
344 op++;
345 GPR_ASSERT(GRPC_CALL_ERROR_INVALID_FLAGS ==
346 grpc_call_start_batch(g_state.call, g_state.ops,
347 (size_t)(op - g_state.ops), tag(1),
348 nullptr));
349 cleanup_test();
350 }
351
test_receive_two_messages_at_the_same_time()352 static void test_receive_two_messages_at_the_same_time() {
353 gpr_log(GPR_INFO, "test_receive_two_messages_at_the_same_time");
354
355 grpc_op* op;
356 grpc_byte_buffer* payload = nullptr;
357 prepare_test(1);
358 op = g_state.ops;
359 op->op = GRPC_OP_RECV_MESSAGE;
360 op->data.recv_message.recv_message = &payload;
361 op->flags = 0;
362 op->reserved = nullptr;
363 op++;
364 op->op = GRPC_OP_RECV_MESSAGE;
365 op->data.recv_message.recv_message = &payload;
366 op->flags = 0;
367 op->reserved = nullptr;
368 op++;
369 GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
370 grpc_call_start_batch(g_state.call, g_state.ops,
371 (size_t)(op - g_state.ops), tag(1),
372 nullptr));
373 cleanup_test();
374 }
375
test_recv_close_on_server_from_client()376 static void test_recv_close_on_server_from_client() {
377 gpr_log(GPR_INFO, "test_recv_close_on_server_from_client");
378
379 grpc_op* op;
380 prepare_test(1);
381
382 op = g_state.ops;
383 op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
384 op->data.recv_close_on_server.cancelled = nullptr;
385 op->flags = 0;
386 op->reserved = nullptr;
387 op++;
388 GPR_ASSERT(GRPC_CALL_ERROR_NOT_ON_CLIENT ==
389 grpc_call_start_batch(g_state.call, g_state.ops,
390 (size_t)(op - g_state.ops), tag(1),
391 nullptr));
392 cleanup_test();
393 }
394
test_recv_status_on_client_twice()395 static void test_recv_status_on_client_twice() {
396 gpr_log(GPR_INFO, "test_recv_status_on_client_twice");
397
398 grpc_op* op;
399 prepare_test(1);
400
401 op = g_state.ops;
402 op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
403 op->data.recv_status_on_client.trailing_metadata =
404 &g_state.trailing_metadata_recv;
405 op->data.recv_status_on_client.status = &g_state.status;
406 op->data.recv_status_on_client.status_details = &g_state.details;
407 op->flags = 0;
408 op->reserved = nullptr;
409 op++;
410 GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(g_state.call, g_state.ops,
411 (size_t)(op - g_state.ops),
412 tag(1), nullptr));
413 CQ_EXPECT_COMPLETION(g_state.cqv, tag(1), 1);
414 cq_verify(g_state.cqv);
415
416 op = g_state.ops;
417 op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
418 op->data.recv_status_on_client.trailing_metadata = nullptr;
419 op->data.recv_status_on_client.status = nullptr;
420 op->data.recv_status_on_client.status_details = nullptr;
421 op->flags = 0;
422 op->reserved = nullptr;
423 op++;
424 GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
425 grpc_call_start_batch(g_state.call, g_state.ops,
426 (size_t)(op - g_state.ops), tag(1),
427 nullptr));
428 cleanup_test();
429 }
430
test_send_close_from_client_on_server()431 static void test_send_close_from_client_on_server() {
432 gpr_log(GPR_INFO, "test_send_close_from_client_on_server");
433
434 grpc_op* op;
435 prepare_test(0);
436
437 op = g_state.ops;
438 op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
439 op->flags = 0;
440 op->reserved = nullptr;
441 op++;
442 GPR_ASSERT(GRPC_CALL_ERROR_NOT_ON_SERVER ==
443 grpc_call_start_batch(g_state.server_call, g_state.ops,
444 (size_t)(op - g_state.ops), tag(2),
445 nullptr));
446 cleanup_test();
447 }
448
test_recv_status_on_client_from_server()449 static void test_recv_status_on_client_from_server() {
450 gpr_log(GPR_INFO, "test_recv_status_on_client_from_server");
451
452 grpc_op* op;
453 prepare_test(0);
454
455 op = g_state.ops;
456 op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
457 op->data.recv_status_on_client.trailing_metadata =
458 &g_state.trailing_metadata_recv;
459 op->data.recv_status_on_client.status = &g_state.status;
460 op->data.recv_status_on_client.status_details = &g_state.details;
461 op->flags = 0;
462 op->reserved = nullptr;
463 op++;
464 GPR_ASSERT(GRPC_CALL_ERROR_NOT_ON_SERVER ==
465 grpc_call_start_batch(g_state.server_call, g_state.ops,
466 (size_t)(op - g_state.ops), tag(2),
467 nullptr));
468 cleanup_test();
469 }
470
test_send_status_from_server_with_invalid_flags()471 static void test_send_status_from_server_with_invalid_flags() {
472 gpr_log(GPR_INFO, "test_send_status_from_server_with_invalid_flags");
473
474 grpc_op* op;
475 prepare_test(0);
476
477 op = g_state.ops;
478 op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
479 op->data.send_status_from_server.trailing_metadata_count = 0;
480 op->data.send_status_from_server.status = GRPC_STATUS_UNIMPLEMENTED;
481 grpc_slice status_details = grpc_slice_from_static_string("xyz");
482 op->data.send_status_from_server.status_details = &status_details;
483 op->flags = 1;
484 op->reserved = nullptr;
485 op++;
486 GPR_ASSERT(GRPC_CALL_ERROR_INVALID_FLAGS ==
487 grpc_call_start_batch(g_state.server_call, g_state.ops,
488 (size_t)(op - g_state.ops), tag(2),
489 nullptr));
490 cleanup_test();
491 }
492
test_too_many_trailing_metadata()493 static void test_too_many_trailing_metadata() {
494 gpr_log(GPR_INFO, "test_too_many_trailing_metadata");
495
496 grpc_op* op;
497 prepare_test(0);
498
499 op = g_state.ops;
500 op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
501 op->data.send_status_from_server.trailing_metadata_count =
502 static_cast<size_t>(INT_MAX) + 1;
503 op->data.send_status_from_server.status = GRPC_STATUS_UNIMPLEMENTED;
504 grpc_slice status_details = grpc_slice_from_static_string("xyz");
505 op->data.send_status_from_server.status_details = &status_details;
506 op->flags = 0;
507 op->reserved = nullptr;
508 op++;
509 GPR_ASSERT(GRPC_CALL_ERROR_INVALID_METADATA ==
510 grpc_call_start_batch(g_state.server_call, g_state.ops,
511 (size_t)(op - g_state.ops), tag(2),
512 nullptr));
513 cleanup_test();
514 }
515
test_send_server_status_twice()516 static void test_send_server_status_twice() {
517 gpr_log(GPR_INFO, "test_send_server_status_twice");
518
519 grpc_op* op;
520 prepare_test(0);
521
522 op = g_state.ops;
523 op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
524 op->data.send_status_from_server.trailing_metadata_count = 0;
525 op->data.send_status_from_server.status = GRPC_STATUS_UNIMPLEMENTED;
526 grpc_slice status_details = grpc_slice_from_static_string("xyz");
527 op->data.send_status_from_server.status_details = &status_details;
528 op->flags = 0;
529 op->reserved = nullptr;
530 op++;
531 op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
532 op->data.send_status_from_server.trailing_metadata_count = 0;
533 op->data.send_status_from_server.status = GRPC_STATUS_UNIMPLEMENTED;
534 op->data.send_status_from_server.status_details = &status_details;
535 op->flags = 0;
536 op->reserved = nullptr;
537 op++;
538 GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
539 grpc_call_start_batch(g_state.server_call, g_state.ops,
540 (size_t)(op - g_state.ops), tag(2),
541 nullptr));
542 cleanup_test();
543 }
544
test_recv_close_on_server_with_invalid_flags()545 static void test_recv_close_on_server_with_invalid_flags() {
546 gpr_log(GPR_INFO, "test_recv_close_on_server_with_invalid_flags");
547
548 grpc_op* op;
549 prepare_test(0);
550
551 op = g_state.ops;
552 op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
553 op->data.recv_close_on_server.cancelled = nullptr;
554 op->flags = 1;
555 op->reserved = nullptr;
556 op++;
557 GPR_ASSERT(GRPC_CALL_ERROR_INVALID_FLAGS ==
558 grpc_call_start_batch(g_state.server_call, g_state.ops,
559 (size_t)(op - g_state.ops), tag(2),
560 nullptr));
561 cleanup_test();
562 }
563
test_recv_close_on_server_twice()564 static void test_recv_close_on_server_twice() {
565 gpr_log(GPR_INFO, "test_recv_close_on_server_twice");
566
567 grpc_op* op;
568 prepare_test(0);
569
570 op = g_state.ops;
571 op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
572 op->data.recv_close_on_server.cancelled = nullptr;
573 op->flags = 0;
574 op->reserved = nullptr;
575 op++;
576 op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
577 op->data.recv_close_on_server.cancelled = nullptr;
578 op->flags = 0;
579 op->reserved = nullptr;
580 op++;
581 GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
582 grpc_call_start_batch(g_state.server_call, g_state.ops,
583 (size_t)(op - g_state.ops), tag(2),
584 nullptr));
585 cleanup_test();
586 }
587
test_invalid_initial_metadata_reserved_key()588 static void test_invalid_initial_metadata_reserved_key() {
589 gpr_log(GPR_INFO, "test_invalid_initial_metadata_reserved_key");
590
591 grpc_metadata metadata;
592 metadata.key = grpc_slice_from_static_string(":start_with_colon");
593 metadata.value = grpc_slice_from_static_string("value");
594
595 grpc_op* op;
596 prepare_test(1);
597 op = g_state.ops;
598 op->op = GRPC_OP_SEND_INITIAL_METADATA;
599 op->data.send_initial_metadata.count = 1;
600 op->data.send_initial_metadata.metadata = &metadata;
601 op->flags = 0;
602 op->reserved = nullptr;
603 op++;
604 GPR_ASSERT(GRPC_CALL_ERROR_INVALID_METADATA ==
605 grpc_call_start_batch(g_state.call, g_state.ops,
606 (size_t)(op - g_state.ops), tag(1),
607 nullptr));
608 cleanup_test();
609 }
610
main(int argc,char ** argv)611 int main(int argc, char** argv) {
612 grpc_test_init(argc, argv);
613 grpc_init();
614 test_invalid_initial_metadata_reserved_key();
615 test_non_null_reserved_on_start_batch();
616 test_non_null_reserved_on_op();
617 test_send_initial_metadata_more_than_once();
618 test_too_many_metadata();
619 test_send_null_message();
620 test_send_messages_at_the_same_time();
621 test_send_server_status_from_client();
622 test_receive_initial_metadata_twice_at_client();
623 test_receive_message_with_invalid_flags();
624 test_receive_two_messages_at_the_same_time();
625 test_recv_close_on_server_from_client();
626 test_recv_status_on_client_twice();
627 test_send_close_from_client_on_server();
628 test_recv_status_on_client_from_server();
629 test_send_status_from_server_with_invalid_flags();
630 test_too_many_trailing_metadata();
631 test_send_server_status_twice();
632 test_recv_close_on_server_with_invalid_flags();
633 test_recv_close_on_server_twice();
634 grpc_shutdown();
635
636 return 0;
637 }
638