Debian Codegraph @

src/test/java/io/airlift/slice/AbstractSliceInputTest.java

raw
1 /*
2 * Licensed under the Apache License, Version 2.0 (the "License");
3 * you may not use this file except in compliance with the License.
4 * You may obtain a copy of the License at
5 *
6 * http://www.apache.org/licenses/LICENSE-2.0
7 *
8 * Unless required by applicable law or agreed to in writing, software
9 * distributed under the License is distributed on an "AS IS" BASIS,
10 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 * See the License for the specific language governing permissions and
12 * limitations under the License.
13 */
14 package io.airlift.slice;
15
16 import com.google.common.base.Throwables;
17 import com.google.common.collect.ImmutableList;
18 import com.google.common.io.ByteSource;
19 import com.google.common.io.ByteStreams;
20 import org.testng.annotations.Test;
21
22 import java.io.ByteArrayOutputStream;
23 import java.io.EOFException;
24 import java.io.IOException;
25 import java.util.List;
26
27 import static com.google.common.collect.Iterables.cycle;
28 import static io.airlift.slice.SizeOf.SIZE_OF_BYTE;
29 import static io.airlift.slice.SizeOf.SIZE_OF_DOUBLE;
30 import static io.airlift.slice.SizeOf.SIZE_OF_FLOAT;
31 import static io.airlift.slice.SizeOf.SIZE_OF_INT;
32 import static io.airlift.slice.SizeOf.SIZE_OF_LONG;
33 import static io.airlift.slice.SizeOf.SIZE_OF_SHORT;
34 import static java.nio.charset.StandardCharsets.UTF_8;
35 import static org.testng.Assert.assertEquals;
36 import static org.testng.Assert.assertTrue;
37 import static org.testng.Assert.fail;
38
39 public abstract class AbstractSliceInputTest
40 {
41 protected static final int BUFFER_SIZE = 129;
42
43 private static final List<Integer> VARIABLE_READ_SIZES = ImmutableList.of(
44 1,
45 7,
46 15,
47 BUFFER_SIZE - 1,
48 BUFFER_SIZE,
49 BUFFER_SIZE + 1,
50 BUFFER_SIZE + 13);
51
52 protected abstract SliceInput createSliceInput(Slice slice);
53
54 @Test
55 public void testReadBoolean()
56 {
57 testSliceInput(new SliceInputTester(SIZE_OF_BYTE)
58 {
59 @Override
60 public void loadValue(SliceOutput output, int valueIndex)
61 {
62 output.writeBoolean(valueIndex % 2 == 0);
63 }
64
65 @Override
66 public void verifyValue(SliceInput input, int valueIndex)
67 {
68 assertEquals(input.readBoolean(), valueIndex % 2 == 0);
69 }
70 });
71 }
72
73 @Test
74 public void testReadByte()
75 {
76 testSliceInput(new SliceInputTester(SIZE_OF_BYTE)
77 {
78 @Override
79 public void loadValue(SliceOutput output, int valueIndex)
80 {
81 output.appendByte((byte) valueIndex);
82 }
83
84 @Override
85 public void verifyValue(SliceInput input, int valueIndex)
86 {
87 assertEquals(input.readByte(), (byte) valueIndex);
88 }
89 });
90 }
91
92 @Test
93 public void testRead()
94 {
95 testSliceInput(new SliceInputTester(SIZE_OF_BYTE)
96 {
97 @Override
98 public void loadValue(SliceOutput output, int valueIndex)
99 {
100 output.appendByte((byte) valueIndex);
101 }
102
103 @Override
104 public void verifyValue(SliceInput input, int valueIndex)
105 {
106 assertEquals(input.read(), valueIndex & 0xFF);
107 }
108
109 @Override
110 public void verifyReadOffEnd(SliceInput input)
111 {
112 assertEquals(input.read(), -1);
113 }
114 });
115 }
116
117 @Test
118 public void testReadShort()
119 {
120 testSliceInput(new SliceInputTester(SIZE_OF_SHORT)
121 {
122 @Override
123 public void loadValue(SliceOutput output, int valueIndex)
124 {
125 output.appendShort(valueIndex);
126 }
127
128 @Override
129 public void verifyValue(SliceInput input, int valueIndex)
130 {
131 assertEquals(input.readShort(), (short) valueIndex);
132 }
133 });
134 }
135
136 @Test
137 public void testReadUnsignedShort()
138 {
139 testSliceInput(new SliceInputTester(SIZE_OF_SHORT)
140 {
141 @Override
142 public void loadValue(SliceOutput output, int valueIndex)
143 {
144 output.appendShort(valueIndex);
145 }
146
147 @Override
148 public void verifyValue(SliceInput input, int valueIndex)
149 {
150 assertEquals(input.readUnsignedShort(), valueIndex & 0xFFF);
151 }
152 });
153 }
154
155 @Test
156 public void testReadInt()
157 {
158 testSliceInput(new SliceInputTester(SIZE_OF_INT)
159 {
160 @Override
161 public void loadValue(SliceOutput output, int valueIndex)
162 {
163 output.appendInt(valueIndex);
164 }
165
166 @Override
167 public void verifyValue(SliceInput input, int valueIndex)
168 {
169 assertEquals(input.readInt(), valueIndex);
170 }
171 });
172 }
173
174 @Test
175 public void testUnsignedReadInt()
176 {
177 testSliceInput(new SliceInputTester(SIZE_OF_INT)
178 {
179 @Override
180 public void loadValue(SliceOutput output, int valueIndex)
181 {
182 output.appendInt(valueIndex);
183 }
184
185 @Override
186 public void verifyValue(SliceInput input, int valueIndex)
187 {
188 assertEquals(input.readUnsignedInt(), valueIndex);
189 }
190 });
191 }
192
193 @Test
194 public void testReadLong()
195 {
196 testSliceInput(new SliceInputTester(SIZE_OF_LONG)
197 {
198 @Override
199 public void loadValue(SliceOutput output, int valueIndex)
200 {
201 output.appendLong(valueIndex);
202 }
203
204 @Override
205 public void verifyValue(SliceInput input, int valueIndex)
206 {
207 assertEquals(input.readLong(), valueIndex);
208 }
209 });
210 }
211
212 @Test
213 public void testReadFloat()
214 {
215 testSliceInput(new SliceInputTester(SIZE_OF_FLOAT)
216 {
217 @Override
218 public void loadValue(SliceOutput output, int valueIndex)
219 {
220 output.writeFloat(valueIndex + 0.12f);
221 }
222
223 @Override
224 public void verifyValue(SliceInput input, int valueIndex)
225 {
226 assertEquals(input.readFloat(), valueIndex + 0.12f);
227 }
228 });
229 }
230
231 @Test
232 public void testReadDouble()
233 {
234 testSliceInput(new SliceInputTester(SIZE_OF_DOUBLE)
235 {
236 @Override
237 public void loadValue(SliceOutput output, int valueIndex)
238 {
239 output.appendDouble(valueIndex + 0.12);
240 }
241
242 @Override
243 public void verifyValue(SliceInput input, int valueIndex)
244 {
245 assertEquals(input.readDouble(), valueIndex + 0.12);
246 }
247 });
248 }
249
250 @Test
251 public void testSkip()
252 {
253 for (int readSize : VARIABLE_READ_SIZES) {
254 // skip without any reads
255 testSliceInput(new SkipSliceInputTester(readSize)
256 {
257 @Override
258 public void verifyValue(SliceInput input, int valueIndex)
259 {
260 input.skip(valueSize());
261 }
262
263 @Override
264 public void verifyReadOffEnd(SliceInput input)
265 {
266 assertEquals(input.skip(valueSize()), valueSize() - 1);
267 }
268 });
269 testSliceInput(new SkipSliceInputTester(readSize)
270 {
271 @Override
272 public void verifyValue(SliceInput input, int valueIndex)
273 {
274 input.skipBytes(valueSize());
275 }
276
277 @Override
278 public void verifyReadOffEnd(SliceInput input)
279 {
280 assertEquals(input.skip(valueSize()), valueSize() - 1);
281 }
282 });
283
284 // read when no data available to force buffering
285 testSliceInput(new SkipSliceInputTester(readSize)
286 {
287 @Override
288 public void verifyValue(SliceInput input, int valueIndex)
289 {
290 int length = valueSize();
291 while (length > 0) {
292 if (!input.isReadable()) {
293 input.readByte();
294 length--;
295 }
296 int skipSize = input.skipBytes(length);
297 length -= skipSize;
298 }
299 assertEquals(input.skip(0), 0);
300 }
301 });
302 testSliceInput(new SkipSliceInputTester(readSize)
303 {
304 @Override
305 public void verifyValue(SliceInput input, int valueIndex)
306 {
307 long length = valueSize();
308 while (length > 0) {
309 if (!input.isReadable()) {
310 input.readByte();
311 length--;
312 }
313 long skipSize = input.skip(length);
314 length -= skipSize;
315 }
316 assertEquals(input.skip(0), 0);
317 }
318 });
319 }
320 }
321
322 @Test
323 public void testReadSlice()
324 {
325 for (int readSize : VARIABLE_READ_SIZES) {
326 testSliceInput(new StringSliceInputTester(readSize)
327 {
328 @Override
329 public String readActual(SliceInput input)
330 {
331 return input.readSlice(valueSize()).toStringUtf8();
332 }
333 });
334 }
335 }
336
337 @Test
338 public void testReadBytes()
339 {
340 for (int readSize : VARIABLE_READ_SIZES) {
341 testSliceInput(new StringSliceInputTester(readSize)
342 {
343 @Override
344 public String readActual(SliceInput input)
345 {
346 Slice slice = Slices.allocate(valueSize());
347 input.readBytes(slice);
348 return slice.toStringUtf8();
349 }
350 });
351 testSliceInput(new StringSliceInputTester(readSize)
352 {
353 @Override
354 public String readActual(SliceInput input)
355 {
356 Slice slice = Slices.allocate(valueSize() + 5);
357 input.readBytes(slice, valueSize());
358 return slice.slice(0, valueSize()).toStringUtf8();
359 }
360 });
361 testSliceInput(new StringSliceInputTester(readSize)
362 {
363 @Override
364 public String readActual(SliceInput input)
365 {
366 Slice slice = Slices.allocate(valueSize() + 10);
367 input.readBytes(slice, 5, valueSize());
368 return slice.slice(5, valueSize()).toStringUtf8();
369 }
370 });
371 testSliceInput(new StringSliceInputTester(readSize)
372 {
373 @Override
374 public String readActual(SliceInput input)
375 {
376 byte[] bytes = new byte[valueSize()];
377 input.readBytes(bytes, 0, valueSize());
378 return new String(bytes, 0, valueSize(), UTF_8);
379 }
380 });
381 testSliceInput(new StringSliceInputTester(readSize)
382 {
383 @Override
384 public String readActual(SliceInput input)
385 {
386 byte[] bytes = new byte[valueSize() + 10];
387 input.readBytes(bytes, 5, valueSize());
388 return new String(bytes, 5, valueSize(), UTF_8);
389 }
390 });
391 testSliceInput(new StringSliceInputTester(readSize)
392 {
393 @Override
394 public String readActual(SliceInput input)
395 {
396 byte[] bytes = new byte[valueSize()];
397 int bytesRead = input.read(bytes);
398 if (bytesRead == -1) {
399 throw new IndexOutOfBoundsException();
400 }
401 assertTrue(bytesRead > 0, "Expected to read at least one byte");
402 input.readBytes(bytes, bytesRead, bytes.length - bytesRead);
403 return new String(bytes, 0, valueSize(), UTF_8);
404 }
405 });
406 testSliceInput(new StringSliceInputTester(readSize)
407 {
408 @Override
409 public String readActual(SliceInput input)
410 {
411 try {
412 byte[] bytes = new byte[valueSize() + 10];
413 ByteStreams.readFully(input, bytes, 5, valueSize());
414 return new String(bytes, 5, valueSize(), UTF_8);
415 }
416 catch (EOFException e) {
417 throw new IndexOutOfBoundsException();
418 }
419 catch (IOException e) {
420 throw Throwables.propagate(e);
421 }
422 }
423 });
424 testSliceInput(new StringSliceInputTester(readSize)
425 {
426 @Override
427 public String readActual(SliceInput input)
428 {
429 try {
430 ByteArrayOutputStream out = new ByteArrayOutputStream();
431 input.readBytes(out, valueSize());
432 return new String(out.toByteArray(), UTF_8);
433 }
434 catch (IOException e) {
435 throw Throwables.propagate(e);
436 }
437 }
438 });
439 }
440 }
441
442 protected void testSliceInput(SliceInputTester tester)
443 {
444 Slice slice = Slices.allocate((BUFFER_SIZE * 3) + 10);
445 SliceOutput output = slice.getOutput();
446 for (int i = 0; i < slice.length() / tester.valueSize(); i++) {
447 tester.loadValue(output, i);
448 }
449 testReadForward(tester, slice);
450 testReadReverse(tester, slice);
451 testReadOffEnd(tester, slice);
452 }
453
454 protected void testReadReverse(SliceInputTester tester, Slice slice)
455 {
456 SliceInput input = createSliceInput(slice);
457 for (int i = slice.length() / tester.valueSize() - 1; i >= 0; i--) {
458 int position = i * tester.valueSize();
459 input.setPosition(position);
460 assertEquals(input.position(), position);
461 tester.verifyValue(input, i);
462 }
463 }
464
465 protected void testReadForward(SliceInputTester tester, Slice slice)
466 {
467 SliceInput input = createSliceInput(slice);
468 for (int i = 0; i < slice.length() / tester.valueSize(); i++) {
469 int position = i * tester.valueSize();
470 assertEquals(input.position(), position);
471 tester.verifyValue(input, i);
472 }
473 }
474
475 protected void testReadOffEnd(SliceInputTester tester, Slice slice)
476 {
477 SliceInput input = createSliceInput(slice);
478 try {
479 ByteStreams.skipFully(input, slice.length() - tester.valueSize() + 1);
480 }
481 catch (IOException e) {
482 throw Throwables.propagate(e);
483 }
484 tester.verifyReadOffEnd(input);
485 }
486
487 private static String getExpectedStringValue(int index, int size)
488 {
489 try {
490 return ByteSource.concat(cycle(ByteSource.wrap(String.valueOf(index).getBytes(UTF_8)))).slice(0, size).asCharSource(UTF_8).read();
491 }
492 catch (IOException e) {
493 throw Throwables.propagate(e);
494 }
495 }
496
497 protected abstract static class SliceInputTester
498 {
499 private final int size;
500
501 public SliceInputTester(int size)
502 {
503 this.size = size;
504 }
505
506 public final int valueSize()
507 {
508 return size;
509 }
510
511 public abstract void loadValue(SliceOutput slice, int valueIndex);
512
513 public abstract void verifyValue(SliceInput input, int valueIndex);
514
515 public void verifyReadOffEnd(SliceInput input)
516 {
517 try {
518 verifyValue(input, 1);
519 fail("expected IndexOutOfBoundsException");
520 }
521 catch (IndexOutOfBoundsException expected) {
522 }
523 }
524 }
525
526 private abstract static class SkipSliceInputTester
527 extends SliceInputTester
528 {
529 public SkipSliceInputTester(int size)
530 {
531 super(size);
532 }
533
534 @Override
535 public void loadValue(SliceOutput output, int valueIndex)
536 {
537 output.writeBytes(new byte[valueSize()]);
538 }
539 }
540
541 private abstract static class StringSliceInputTester
542 extends SliceInputTester
543 {
544 public StringSliceInputTester(int size)
545 {
546 super(size);
547 }
548
549 @Override
550 public final void loadValue(SliceOutput output, int valueIndex)
551 {
552 output.writeBytes(getExpectedStringValue(valueIndex, valueSize()).getBytes(UTF_8));
553 }
554
555 @Override
556 public final void verifyValue(SliceInput input, int valueIndex)
557 {
558 String actual = readActual(input);
559 String expected = getExpectedStringValue(valueIndex, valueSize());
560 assertEquals(actual, expected);
561 }
562
563 protected abstract String readActual(SliceInput input);
564 }
565 }