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 <string.h>
20
21 #include <memory>
22
23 #include "gtest/gtest.h"
24
25 #include <grpc/byte_buffer.h>
26 #include <grpc/byte_buffer_reader.h>
27 #include <grpc/compression.h>
28 #include <grpc/grpc.h>
29 #include <grpc/slice.h>
30 #include <grpc/support/log.h>
31
32 #include "test/core/util/test_config.h"
33
34 #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x)
35
TEST(GrpcByteBufferReaderTest,TestReadOneSlice)36 TEST(GrpcByteBufferReaderTest, TestReadOneSlice) {
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 ASSERT_TRUE(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 ASSERT_NE(first_code, 0);
51 ASSERT_EQ(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 ASSERT_EQ(second_code, 0);
55 grpc_byte_buffer_destroy(buffer);
56 }
57
TEST(GrpcByteBufferReaderTest,TestReadOneSliceMalloc)58 TEST(GrpcByteBufferReaderTest, TestReadOneSliceMalloc) {
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 ASSERT_TRUE(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 ASSERT_NE(first_code, 0);
74 ASSERT_EQ(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 ASSERT_EQ(second_code, 0);
78 grpc_byte_buffer_destroy(buffer);
79 }
80
TEST(GrpcByteBufferReaderTest,TestReadNoneCompressedSlice)81 TEST(GrpcByteBufferReaderTest, TestReadNoneCompressedSlice) {
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 ASSERT_TRUE(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 ASSERT_NE(first_code, 0);
96 ASSERT_EQ(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 ASSERT_EQ(second_code, 0);
100 grpc_byte_buffer_destroy(buffer);
101 }
102
TEST(GrpcByteBufferReaderTest,TestPeekOneSlice)103 TEST(GrpcByteBufferReaderTest, TestPeekOneSlice) {
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 ASSERT_TRUE(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 ASSERT_NE(first_code, 0);
119 ASSERT_EQ(memcmp(GRPC_SLICE_START_PTR(*first_slice), "test", 4), 0);
120 second_code = grpc_byte_buffer_reader_peek(&reader, &second_slice);
121 ASSERT_EQ(second_code, 0);
122 grpc_byte_buffer_destroy(buffer);
123 }
124
TEST(GrpcByteBufferReaderTest,TestPeekOneSliceMalloc)125 TEST(GrpcByteBufferReaderTest, TestPeekOneSliceMalloc) {
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 ASSERT_TRUE(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 ASSERT_NE(first_code, 0);
142 ASSERT_EQ(memcmp(GRPC_SLICE_START_PTR(*first_slice), "test", 4), 0);
143 second_code = grpc_byte_buffer_reader_peek(&reader, &second_slice);
144 ASSERT_EQ(second_code, 0);
145 grpc_byte_buffer_destroy(buffer);
146 }
147
TEST(GrpcByteBufferReaderTest,TestPeekNoneCompressedSlice)148 TEST(GrpcByteBufferReaderTest, TestPeekNoneCompressedSlice) {
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 ASSERT_TRUE(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 ASSERT_NE(first_code, 0);
164 ASSERT_EQ(memcmp(GRPC_SLICE_START_PTR(*first_slice), "test", 4), 0);
165 second_code = grpc_byte_buffer_reader_peek(&reader, &second_slice);
166 ASSERT_EQ(second_code, 0);
167 grpc_byte_buffer_destroy(buffer);
168 }
169
TEST(GrpcByteBufferReaderTest,TestByteBufferFromReader)170 TEST(GrpcByteBufferReaderTest, TestByteBufferFromReader) {
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 ASSERT_TRUE(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 ASSERT_EQ(buffer->type, buffer_from_reader->type);
185 ASSERT_EQ(buffer_from_reader->data.raw.compression, GRPC_COMPRESS_NONE);
186 ASSERT_EQ(buffer_from_reader->data.raw.slice_buffer.count, 1);
187 ASSERT_EQ(memcmp(GRPC_SLICE_START_PTR(
188 buffer_from_reader->data.raw.slice_buffer.slices[0]),
189 "test", 4),
190 0);
191
192 grpc_byte_buffer_destroy(buffer);
193 grpc_byte_buffer_destroy(buffer_from_reader);
194 }
195
TEST(GrpcByteBufferReaderTest,TestReadall)196 TEST(GrpcByteBufferReaderTest, TestReadall) {
197 char* lotsa_as[512];
198 char* lotsa_bs[1024];
199 grpc_slice slices[2];
200 grpc_byte_buffer* buffer;
201 grpc_byte_buffer_reader reader;
202 grpc_slice slice_out;
203
204 LOG_TEST("test_readall");
205
206 memset(lotsa_as, 'a', 512 * sizeof(lotsa_as[0]));
207 memset(lotsa_bs, 'b', 1024 * sizeof(lotsa_bs[0]));
208 // use slices large enough to overflow inlining
209 slices[0] = grpc_slice_malloc(512);
210 memcpy(GRPC_SLICE_START_PTR(slices[0]), lotsa_as, 512);
211 slices[1] = grpc_slice_malloc(1024);
212 memcpy(GRPC_SLICE_START_PTR(slices[1]), lotsa_bs, 1024);
213
214 buffer = grpc_raw_byte_buffer_create(slices, 2);
215 grpc_slice_unref(slices[0]);
216 grpc_slice_unref(slices[1]);
217
218 ASSERT_TRUE(grpc_byte_buffer_reader_init(&reader, buffer) &&
219 "Couldn't init byte buffer reader");
220 slice_out = grpc_byte_buffer_reader_readall(&reader);
221
222 ASSERT_EQ(GRPC_SLICE_LENGTH(slice_out), 512 + 1024);
223 ASSERT_EQ(memcmp(GRPC_SLICE_START_PTR(slice_out), lotsa_as, 512), 0);
224 ASSERT_EQ(memcmp(&(GRPC_SLICE_START_PTR(slice_out)[512]), lotsa_bs, 1024), 0);
225 grpc_slice_unref(slice_out);
226 grpc_byte_buffer_destroy(buffer);
227 }
228
TEST(GrpcByteBufferReaderTest,TestByteBufferCopy)229 TEST(GrpcByteBufferReaderTest, TestByteBufferCopy) {
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 ASSERT_TRUE(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 ASSERT_EQ(GRPC_SLICE_LENGTH(slice_out), 512 + 1024);
258 ASSERT_EQ(memcmp(GRPC_SLICE_START_PTR(slice_out), lotsa_as, 512), 0);
259 ASSERT_EQ(memcmp(&(GRPC_SLICE_START_PTR(slice_out)[512]), lotsa_bs, 1024), 0);
260 grpc_slice_unref(slice_out);
261 grpc_byte_buffer_destroy(buffer);
262 grpc_byte_buffer_destroy(copied_buffer);
263 }
264
main(int argc,char ** argv)265 int main(int argc, char** argv) {
266 grpc::testing::TestEnvironment env(&argc, argv);
267 ::testing::InitGoogleTest(&argc, argv);
268 grpc::testing::TestGrpcScope grpc_scope;
269 return RUN_ALL_TESTS();
270 }
271