Line data Source code
1 : /*
2 : *
3 : * Copyright 2015, Google Inc.
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/channel/channel_stack.h"
35 :
36 : #include <string.h>
37 :
38 : #include <grpc/support/alloc.h>
39 : #include <grpc/support/log.h>
40 : #include <grpc/support/string_util.h>
41 :
42 : #include "test/core/util/test_config.h"
43 :
44 1 : static void channel_init_func(grpc_exec_ctx *exec_ctx,
45 : grpc_channel_element *elem, grpc_channel *master,
46 : const grpc_channel_args *args,
47 : grpc_mdctx *metadata_context, int is_first,
48 : int is_last) {
49 1 : GPR_ASSERT(args->num_args == 1);
50 1 : GPR_ASSERT(args->args[0].type == GRPC_ARG_INTEGER);
51 1 : GPR_ASSERT(0 == strcmp(args->args[0].key, "test_key"));
52 1 : GPR_ASSERT(args->args[0].value.integer == 42);
53 1 : GPR_ASSERT(is_first);
54 1 : GPR_ASSERT(is_last);
55 1 : *(int *)(elem->channel_data) = 0;
56 1 : }
57 :
58 1 : static void call_init_func(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
59 : const void *server_transport_data,
60 : grpc_transport_stream_op *initial_op) {
61 1 : ++*(int *)(elem->channel_data);
62 1 : *(int *)(elem->call_data) = 0;
63 1 : }
64 :
65 1 : static void channel_destroy_func(grpc_exec_ctx *exec_ctx,
66 1 : grpc_channel_element *elem) {}
67 :
68 1 : static void call_destroy_func(grpc_exec_ctx *exec_ctx,
69 : grpc_call_element *elem) {
70 1 : ++*(int *)(elem->channel_data);
71 1 : }
72 :
73 0 : static void call_func(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
74 : grpc_transport_stream_op *op) {
75 0 : ++*(int *)(elem->call_data);
76 0 : }
77 :
78 0 : static void channel_func(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem,
79 : grpc_transport_op *op) {
80 0 : ++*(int *)(elem->channel_data);
81 0 : }
82 :
83 0 : static char *get_peer(grpc_exec_ctx *exec_ctx, grpc_call_element *elem) {
84 0 : return gpr_strdup("peer");
85 : }
86 :
87 1 : static void test_create_channel_stack(void) {
88 1 : const grpc_channel_filter filter = {
89 : call_func, channel_func, sizeof(int), call_init_func, call_destroy_func,
90 : sizeof(int), channel_init_func, channel_destroy_func, get_peer,
91 : "some_test_filter"};
92 1 : const grpc_channel_filter *filters = &filter;
93 : grpc_channel_stack *channel_stack;
94 : grpc_call_stack *call_stack;
95 : grpc_channel_element *channel_elem;
96 : grpc_call_element *call_elem;
97 : grpc_arg arg;
98 : grpc_channel_args chan_args;
99 : grpc_mdctx *metadata_context;
100 : int *channel_data;
101 : int *call_data;
102 1 : grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
103 :
104 1 : metadata_context = grpc_mdctx_create();
105 :
106 1 : arg.type = GRPC_ARG_INTEGER;
107 1 : arg.key = "test_key";
108 1 : arg.value.integer = 42;
109 :
110 1 : chan_args.num_args = 1;
111 1 : chan_args.args = &arg;
112 :
113 1 : channel_stack = gpr_malloc(grpc_channel_stack_size(&filters, 1));
114 1 : grpc_channel_stack_init(&exec_ctx, &filters, 1, NULL, &chan_args,
115 : metadata_context, channel_stack);
116 1 : GPR_ASSERT(channel_stack->count == 1);
117 1 : channel_elem = grpc_channel_stack_element(channel_stack, 0);
118 1 : channel_data = (int *)channel_elem->channel_data;
119 1 : GPR_ASSERT(*channel_data == 0);
120 :
121 1 : call_stack = gpr_malloc(channel_stack->call_stack_size);
122 1 : grpc_call_stack_init(&exec_ctx, channel_stack, NULL, NULL, call_stack);
123 1 : GPR_ASSERT(call_stack->count == 1);
124 1 : call_elem = grpc_call_stack_element(call_stack, 0);
125 1 : GPR_ASSERT(call_elem->filter == channel_elem->filter);
126 1 : GPR_ASSERT(call_elem->channel_data == channel_elem->channel_data);
127 1 : call_data = (int *)call_elem->call_data;
128 1 : GPR_ASSERT(*call_data == 0);
129 1 : GPR_ASSERT(*channel_data == 1);
130 :
131 1 : grpc_call_stack_destroy(&exec_ctx, call_stack);
132 1 : gpr_free(call_stack);
133 1 : GPR_ASSERT(*channel_data == 2);
134 :
135 1 : grpc_channel_stack_destroy(&exec_ctx, channel_stack);
136 1 : gpr_free(channel_stack);
137 :
138 1 : grpc_mdctx_unref(metadata_context);
139 :
140 1 : grpc_exec_ctx_finish(&exec_ctx);
141 1 : }
142 :
143 1 : int main(int argc, char **argv) {
144 1 : grpc_test_init(argc, argv);
145 1 : test_create_channel_stack();
146 1 : return 0;
147 : }
|
