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