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