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/byte_buffer.h>
20 #include <grpc/byte_buffer_reader.h>
21 #include <grpc/grpc.h>
22 #include <grpc/slice.h>
23
24 #include <grpc/support/alloc.h>
25 #include <grpc/support/log.h>
26 #include <grpc/support/time.h>
27
28 #include "src/core/lib/gprpp/thd.h"
29 #include "src/core/lib/iomgr/exec_ctx.h"
30 #include "test/core/util/test_config.h"
31
32 #include <string.h>
33
34 #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x)
35
test_read_one_slice(void)36 static void test_read_one_slice(void) {
37 grpc_slice slice;
38 grpc_byte_buffer* buffer;
39 grpc_byte_buffer_reader reader;
40 grpc_slice first_slice, second_slice;
41 int first_code, second_code;
42
43 LOG_TEST("test_read_one_slice");
44 slice = grpc_slice_from_copied_string("test");
45 buffer = grpc_raw_byte_buffer_create(&slice, 1);
46 grpc_slice_unref(slice);
47 GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, buffer) &&
48 "Couldn't init byte buffer reader");
49 first_code = grpc_byte_buffer_reader_next(&reader, &first_slice);
50 GPR_ASSERT(first_code != 0);
51 GPR_ASSERT(memcmp(GRPC_SLICE_START_PTR(first_slice), "test", 4) == 0);
52 grpc_slice_unref(first_slice);
53 second_code = grpc_byte_buffer_reader_next(&reader, &second_slice);
54 GPR_ASSERT(second_code == 0);
55 grpc_byte_buffer_destroy(buffer);
56 }
57
test_read_one_slice_malloc(void)58 static void test_read_one_slice_malloc(void) {
59 grpc_slice slice;
60 grpc_byte_buffer* buffer;
61 grpc_byte_buffer_reader reader;
62 grpc_slice first_slice, second_slice;
63 int first_code, second_code;
64
65 LOG_TEST("test_read_one_slice_malloc");
66 slice = grpc_slice_malloc(4);
67 memcpy(GRPC_SLICE_START_PTR(slice), "test", 4);
68 buffer = grpc_raw_byte_buffer_create(&slice, 1);
69 grpc_slice_unref(slice);
70 GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, buffer) &&
71 "Couldn't init byte buffer reader");
72 first_code = grpc_byte_buffer_reader_next(&reader, &first_slice);
73 GPR_ASSERT(first_code != 0);
74 GPR_ASSERT(memcmp(GRPC_SLICE_START_PTR(first_slice), "test", 4) == 0);
75 grpc_slice_unref(first_slice);
76 second_code = grpc_byte_buffer_reader_next(&reader, &second_slice);
77 GPR_ASSERT(second_code == 0);
78 grpc_byte_buffer_destroy(buffer);
79 }
80
test_read_none_compressed_slice(void)81 static void test_read_none_compressed_slice(void) {
82 grpc_slice slice;
83 grpc_byte_buffer* buffer;
84 grpc_byte_buffer_reader reader;
85 grpc_slice first_slice, second_slice;
86 int first_code, second_code;
87
88 LOG_TEST("test_read_none_compressed_slice");
89 slice = grpc_slice_from_copied_string("test");
90 buffer = grpc_raw_byte_buffer_create(&slice, 1);
91 grpc_slice_unref(slice);
92 GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, buffer) &&
93 "Couldn't init byte buffer reader");
94 first_code = grpc_byte_buffer_reader_next(&reader, &first_slice);
95 GPR_ASSERT(first_code != 0);
96 GPR_ASSERT(memcmp(GRPC_SLICE_START_PTR(first_slice), "test", 4) == 0);
97 grpc_slice_unref(first_slice);
98 second_code = grpc_byte_buffer_reader_next(&reader, &second_slice);
99 GPR_ASSERT(second_code == 0);
100 grpc_byte_buffer_destroy(buffer);
101 }
102
test_peek_one_slice(void)103 static void test_peek_one_slice(void) {
104 grpc_slice slice;
105 grpc_byte_buffer* buffer;
106 grpc_byte_buffer_reader reader;
107 grpc_slice* first_slice;
108 grpc_slice* second_slice;
109 int first_code, second_code;
110
111 LOG_TEST("test_peek_one_slice");
112 slice = grpc_slice_from_copied_string("test");
113 buffer = grpc_raw_byte_buffer_create(&slice, 1);
114 grpc_slice_unref(slice);
115 GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, buffer) &&
116 "Couldn't init byte buffer reader");
117 first_code = grpc_byte_buffer_reader_peek(&reader, &first_slice);
118 GPR_ASSERT(first_code != 0);
119 GPR_ASSERT(memcmp(GRPC_SLICE_START_PTR(*first_slice), "test", 4) == 0);
120 second_code = grpc_byte_buffer_reader_peek(&reader, &second_slice);
121 GPR_ASSERT(second_code == 0);
122 grpc_byte_buffer_destroy(buffer);
123 }
124
test_peek_one_slice_malloc(void)125 static void test_peek_one_slice_malloc(void) {
126 grpc_slice slice;
127 grpc_byte_buffer* buffer;
128 grpc_byte_buffer_reader reader;
129 grpc_slice* first_slice;
130 grpc_slice* second_slice;
131 int first_code, second_code;
132
133 LOG_TEST("test_peek_one_slice_malloc");
134 slice = grpc_slice_malloc(4);
135 memcpy(GRPC_SLICE_START_PTR(slice), "test", 4);
136 buffer = grpc_raw_byte_buffer_create(&slice, 1);
137 grpc_slice_unref(slice);
138 GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, buffer) &&
139 "Couldn't init byte buffer reader");
140 first_code = grpc_byte_buffer_reader_peek(&reader, &first_slice);
141 GPR_ASSERT(first_code != 0);
142 GPR_ASSERT(memcmp(GRPC_SLICE_START_PTR(*first_slice), "test", 4) == 0);
143 second_code = grpc_byte_buffer_reader_peek(&reader, &second_slice);
144 GPR_ASSERT(second_code == 0);
145 grpc_byte_buffer_destroy(buffer);
146 }
147
test_peek_none_compressed_slice(void)148 static void test_peek_none_compressed_slice(void) {
149 grpc_slice slice;
150 grpc_byte_buffer* buffer;
151 grpc_byte_buffer_reader reader;
152 grpc_slice* first_slice;
153 grpc_slice* second_slice;
154 int first_code, second_code;
155
156 LOG_TEST("test_peek_none_compressed_slice");
157 slice = grpc_slice_from_copied_string("test");
158 buffer = grpc_raw_byte_buffer_create(&slice, 1);
159 grpc_slice_unref(slice);
160 GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, buffer) &&
161 "Couldn't init byte buffer reader");
162 first_code = grpc_byte_buffer_reader_peek(&reader, &first_slice);
163 GPR_ASSERT(first_code != 0);
164 GPR_ASSERT(memcmp(GRPC_SLICE_START_PTR(*first_slice), "test", 4) == 0);
165 second_code = grpc_byte_buffer_reader_peek(&reader, &second_slice);
166 GPR_ASSERT(second_code == 0);
167 grpc_byte_buffer_destroy(buffer);
168 }
169
test_byte_buffer_from_reader(void)170 static void test_byte_buffer_from_reader(void) {
171 grpc_slice slice;
172 grpc_byte_buffer *buffer, *buffer_from_reader;
173 grpc_byte_buffer_reader reader;
174
175 LOG_TEST("test_byte_buffer_from_reader");
176 slice = grpc_slice_malloc(4);
177 memcpy(GRPC_SLICE_START_PTR(slice), "test", 4);
178 buffer = grpc_raw_byte_buffer_create(&slice, 1);
179 grpc_slice_unref(slice);
180 GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, buffer) &&
181 "Couldn't init byte buffer reader");
182
183 buffer_from_reader = grpc_raw_byte_buffer_from_reader(&reader);
184 GPR_ASSERT(buffer->type == buffer_from_reader->type);
185 GPR_ASSERT(buffer_from_reader->data.raw.compression == GRPC_COMPRESS_NONE);
186 GPR_ASSERT(buffer_from_reader->data.raw.slice_buffer.count == 1);
187 GPR_ASSERT(memcmp(GRPC_SLICE_START_PTR(
188 buffer_from_reader->data.raw.slice_buffer.slices[0]),
189 "test", 4) == 0);
190
191 grpc_byte_buffer_destroy(buffer);
192 grpc_byte_buffer_destroy(buffer_from_reader);
193 }
194
test_readall(void)195 static void test_readall(void) {
196 char* lotsa_as[512];
197 char* lotsa_bs[1024];
198 grpc_slice slices[2];
199 grpc_byte_buffer* buffer;
200 grpc_byte_buffer_reader reader;
201 grpc_slice slice_out;
202
203 LOG_TEST("test_readall");
204
205 memset(lotsa_as, 'a', 512 * sizeof(lotsa_as[0]));
206 memset(lotsa_bs, 'b', 1024 * sizeof(lotsa_bs[0]));
207 /* use slices large enough to overflow inlining */
208 slices[0] = grpc_slice_malloc(512);
209 memcpy(GRPC_SLICE_START_PTR(slices[0]), lotsa_as, 512);
210 slices[1] = grpc_slice_malloc(1024);
211 memcpy(GRPC_SLICE_START_PTR(slices[1]), lotsa_bs, 1024);
212
213 buffer = grpc_raw_byte_buffer_create(slices, 2);
214 grpc_slice_unref(slices[0]);
215 grpc_slice_unref(slices[1]);
216
217 GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, buffer) &&
218 "Couldn't init byte buffer reader");
219 slice_out = grpc_byte_buffer_reader_readall(&reader);
220
221 GPR_ASSERT(GRPC_SLICE_LENGTH(slice_out) == 512 + 1024);
222 GPR_ASSERT(memcmp(GRPC_SLICE_START_PTR(slice_out), lotsa_as, 512) == 0);
223 GPR_ASSERT(memcmp(&(GRPC_SLICE_START_PTR(slice_out)[512]), lotsa_bs, 1024) ==
224 0);
225 grpc_slice_unref(slice_out);
226 grpc_byte_buffer_destroy(buffer);
227 }
228
test_byte_buffer_copy(void)229 static void test_byte_buffer_copy(void) {
230 char* lotsa_as[512];
231 char* lotsa_bs[1024];
232 grpc_slice slices[2];
233 grpc_byte_buffer* buffer;
234 grpc_byte_buffer* copied_buffer;
235 grpc_byte_buffer_reader reader;
236 grpc_slice slice_out;
237
238 LOG_TEST("test_byte_buffer_copy");
239
240 memset(lotsa_as, 'a', 512 * sizeof(lotsa_as[0]));
241 memset(lotsa_bs, 'b', 1024 * sizeof(lotsa_bs[0]));
242 /* use slices large enough to overflow inlining */
243 slices[0] = grpc_slice_malloc(512);
244 memcpy(GRPC_SLICE_START_PTR(slices[0]), lotsa_as, 512);
245 slices[1] = grpc_slice_malloc(1024);
246 memcpy(GRPC_SLICE_START_PTR(slices[1]), lotsa_bs, 1024);
247
248 buffer = grpc_raw_byte_buffer_create(slices, 2);
249 grpc_slice_unref(slices[0]);
250 grpc_slice_unref(slices[1]);
251 copied_buffer = grpc_byte_buffer_copy(buffer);
252
253 GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, buffer) &&
254 "Couldn't init byte buffer reader");
255 slice_out = grpc_byte_buffer_reader_readall(&reader);
256
257 GPR_ASSERT(GRPC_SLICE_LENGTH(slice_out) == 512 + 1024);
258 GPR_ASSERT(memcmp(GRPC_SLICE_START_PTR(slice_out), lotsa_as, 512) == 0);
259 GPR_ASSERT(memcmp(&(GRPC_SLICE_START_PTR(slice_out)[512]), lotsa_bs, 1024) ==
260 0);
261 grpc_slice_unref(slice_out);
262 grpc_byte_buffer_destroy(buffer);
263 grpc_byte_buffer_destroy(copied_buffer);
264 }
265
main(int argc,char ** argv)266 int main(int argc, char** argv) {
267 grpc_init();
268 grpc::testing::TestEnvironment env(argc, argv);
269 test_read_one_slice();
270 test_read_one_slice_malloc();
271 test_read_none_compressed_slice();
272 test_peek_one_slice();
273 test_peek_one_slice_malloc();
274 test_peek_none_compressed_slice();
275 test_byte_buffer_from_reader();
276 test_byte_buffer_copy();
277 test_readall();
278 grpc_shutdown();
279 return 0;
280 }
281